public async Task <string> AddUpdateUser(EmployeeVM employeeVM)
{
EmployeeDomainModel employeeDM = new EmployeeDomainModel();
AutoMapper.Mapper.Map(employeeVM, employeeDM);
return(await employeeBusiness.AddUpdateEmployee(employeeDM));
}
public EmployeeDomainModel AddEditEmployee(EmployeeDomainModel domainModel)
{
if (domainModel.EmployeeId > 0)
{
//update
Employee employee = empRepository.SingleOrDefault(x => x.EmployeeId == domainModel.EmployeeId && x.IsDeleted == false);
employee.DepartmentId = domainModel.DepartmentId;
employee.Name = domainModel.Name;
employee.Address = domainModel.Address;
empRepository.Update(employee);
}
else
{
//Insert
Employee employee = new Employee();
employee.Address = domainModel.Address;
employee.Name = domainModel.Name;
employee.DepartmentId = domainModel.DepartmentId;
employee.IsDeleted = false;
empRepository.Insert(employee);
domainModel.EmployeeId = employee.EmployeeId;
}
return(domainModel);
}
public HttpResponseMessage GetEmployeeDataById(long UserId)
{
try
{
HttpResponseMessage httpResponse = new HttpResponseMessage();
EmployeeDomainModel objRes = new EmployeeDomainModel();
objRes = managementRepository.GetEmployeeDataById(UserId);
if (objRes != null)
{
httpResponse = Request.CreateResponse(HttpStatusCode.OK, objRes);
}
else
{
httpResponse = Request.CreateResponse(HttpStatusCode.Unauthorized, objRes);
}
return(httpResponse);
}
catch (Exception ex)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent("An error occurred, please try again or contact the administrator."),
ReasonPhrase = "An error occurred, please try again or contact the administrator.",
StatusCode = HttpStatusCode.InternalServerError
});
}
}
public HttpResponseMessage AddUpdateEmployee(EmployeeDomainModel model)
{
try
{
HttpResponseMessage httpResponse = new HttpResponseMessage();
var res = managementRepository.AddUpdateEmployee(model);
if (res != null && res.isSuccess)
{
httpResponse = Request.CreateResponse(HttpStatusCode.OK, res);
}
else
{
httpResponse = Request.CreateResponse(HttpStatusCode.Unauthorized, res);
}
return(httpResponse);
}
catch (Exception ex)
{
ErrorLog.LogError(ex);
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent("An error occurred, please try again or contact the administrator."),
ReasonPhrase = "An error occurred, please try again or contact the administrator.",
StatusCode = HttpStatusCode.InternalServerError
});
}
}
public IHttpActionResult Put(short id, EmployeeDomainModel employee)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != employee.EMPLOYEE_ID)
{
return(BadRequest());
}
try
{
db.PutSingleEmployee(employee);
}
catch (DbUpdateConcurrencyException)
{
if (!db.EmployeeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
/// <summary>
/// Get Employees for Id provided.
/// </summary>
/// <param name="employeeid">employeeid</param>
/// <returns>EmployeeDomainModel object; otherwise, Exception.</returns>
public EmployeeDomainModel SelectEmployeesById(int employeeid)
{
// intercept the data from the DAL
EmployeeDomainModel employee = HideHomePhone(DAL.SelectEmployeesById(employeeid));
return(employee);
}
public void DataToDomaonModelMustMatch()
{
var timeStamp = DateTime.Now;
var sourceDataModel = new Employee()
{
ID = 1,
Created = timeStamp,
RowVersion = "rowversion",
FirstName = "John",
LastName = "Smith",
Department = null
};
var expectedDomainModel = new EmployeeDomainModel()
{
ID = 1,
Created = timeStamp,
RowVersion = "rowversion",
FirstName = "John",
LastName = "Smith",
};
var mappedDomainModel = _mapper.Map <IEmployeeDomainModel>(sourceDataModel);
mappedDomainModel.Should().BeEquivalentTo(expectedDomainModel);
}
public string AddUpdateEmployee(EmployeeDomainModel empModel)
{
string result = "";
if (empModel.EmployeeId > 0)
{
Employee emp = empRepository.SingleOrDefault(x => x.EmployeeId == empModel.EmployeeId);
if (emp != null)
{
emp.Name = empModel.Name;
emp.DepartmentId = empModel.DepartmentId;
emp.Address = empModel.Address;
empRepository.Update(emp);
result = "updated";
}
}
else
{
Employee emp = new Employee();
emp.Name = empModel.Name;
emp.DepartmentId = empModel.DepartmentId;
emp.Address = empModel.Address;
emp.IsDeleted = false;
var record = empRepository.Insert(emp);
result = "Inserted";
}
return(result);
}
public async Task <IActionResult> UpdateAsync(Guid id, [FromBody] EmployeeDomainModel model)
{
if (model == null || model.EmployeeId != id)
{
return(BadRequest("The model that is passed in is empty. Model object is required."));
}
EmployeeDomainModel selected;
try
{
selected = await _domain.GetAsync(id).ConfigureAwait(false);
if (selected == null)
{
return(NotFound("The asset category selected to be updated could not be found."));
}
}
catch (Exception ex) { return(BadRequest(ex.InnerException)); }
selected.FirstName = model.FirstName;
selected.LastName = model.LastName;
selected.ModifiedDate = DateTime.UtcNow;
try { await _domain.UpdateAsync(selected).ConfigureAwait(false); }
catch (Exception ex) { return(BadRequest(ex.InnerException)); }
return(Ok(selected));
}
public async Task <EmployeeToReturnVM> GetEmployeeById(int id)
{
EmployeeToReturnVM employeeToReturnVM = new EmployeeToReturnVM();
EmployeeDomainModel employeeDomainModel = await employeeBusiness.GetEmployeeById(id);
AutoMapper.Mapper.Map(employeeDomainModel, employeeToReturnVM);
return(employeeToReturnVM);
}
/// <summary>
/// Insert a new employee record into the Northwind database.
/// </summary>
/// <param name="employee">Employee object</param>
/// <returns>int; otherwise, Exception.</returns>
public int InsertEmployee(EmployeeDomainModel employee)
{
// Create a context object wrapped in a using statement.
using (NorthwindEntities northwindConnection = new NorthwindEntities())
{
return(northwindConnection.InsertEmployee(employee.LastName, employee.FirstName, employee.Title, employee.HomePhone));
}
}
/// <summary>
/// Hide Home Phone Number Business Rule
/// </summary>
/// <param name="obj">EmployeeDomainModel object</param>
/// <returns>EmployeeDomainModel object; otherwise, Exception.</returns>
private EmployeeDomainModel HideHomePhone(EmployeeDomainModel obj)
{
// apply a business rule.
if (obj.Title.Contains("Manager"))
{
obj.HomePhone = "Not Available";
}
return(obj);
}
public void PutSingleEmployee(EmployeeDomainModel employee)
{
//db.Entry(employee).State = EntityState.Modified;
EMPLOYEE emp = db.EMPLOYEEs.SingleOrDefault(t => t.EMPLOYEE_ID == employee.EMPLOYEE_ID);
emp.EMPLOYEE_NAME = employee.EMPLOYEE_NAME;
emp.EMPLOYEE_SALARY = employee.EMPLOYEE_SALARY;
emp.EMPLOYEE_DEPARTMENT = employee.EMPLOYEE_DEPARTMENT;
db.SaveChanges();
}
/// <summary>
/// Convert From EmployeeDomainModel To Employee
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public static Employee Map(EmployeeDomainModel obj)
{
return(new Employee
{
EmployeeId = obj.EmployeeId,
FirstName = obj.FirstName,
HomePhone = obj.HomePhone,
LastName = obj.LastName,
Title = obj.Title
});
}
public EmployeeDomainModel GetSingleEmployee(int empID)
{
EmployeeDomainModel single = db.EMPLOYEEs.Where(t => t.EMPLOYEE_ID == empID).Select(t => new EmployeeDomainModel
{
EMPLOYEE_ID = t.EMPLOYEE_ID,
EMPLOYEE_NAME = t.EMPLOYEE_NAME,
EMPLOYEE_SALARY = t.EMPLOYEE_SALARY,
EMPLOYEE_DEPARTMENT = t.EMPLOYEE_DEPARTMENT
}).First();
return(single);
}
public async Task <IActionResult> DeleteAsync(Guid id)
{
if (id == Guid.Empty)
{
return(BadRequest());
}
EmployeeDomainModel deleted = null;
try { deleted = await _domain.DeleteAsync(id).ConfigureAwait(false); }
catch (Exception ex) { return(BadRequest(ex.InnerException)); }
return(Ok(deleted));
}
public async Task <IActionResult> CreateAsync([FromBody] EmployeeDomainModel model)
{
if (model == null)
{
return(BadRequest("The model that is passed in is empty. Model object is required."));
}
EmployeeDomainModel inserted;
try { inserted = await _domain.InsertAsync(model).ConfigureAwait(false); }
catch (Exception ex) { return(BadRequest(ex.InnerException)); }
return(CreatedAtRoute("GetEmployee", new { id = inserted.EmployeeId }, inserted));
}
public EmployeeDomainModel GetEmployeeById(int Id)
{
EmployeeDomainModel empDomainModel = new EmployeeDomainModel();
Employee emp = empRepository.SingleOrDefault(x => x.EmployeeId == Id && x.IsDeleted == false);
if (emp != null)
{
empDomainModel.EmployeeId = emp.EmployeeId;
empDomainModel.DepartmentId = emp.DepartmentId;
empDomainModel.Name = emp.Name;
empDomainModel.Address = emp.Address;
}
return(empDomainModel);
}
public ActionResult AddEditEmployee(EmployeeViewModel empView)
{
string result = "";
empView.EmpId = empView.EmpId;
empView.Name = empView.Name;
empView.Address = empView.Address;
empView.DeptId = empView.DeptId;
EmployeeDomainModel empDoModel = new EmployeeDomainModel();
AutoMapper.Mapper.Map(empView, empDoModel);
result = _emp.AddEditEmp(empDoModel);
return(Json(new { success = true, message = "Saved Successfully" }, JsonRequestBehavior.AllowGet));
}
/// <summary> <see cref="IEmployeeDomain.InsertAsync"/> </summary>
/// <exception cref="ArgumentNullException"><paramref name="domainModel"/> is <see langword="null"/></exception>
public async Task <EmployeeDomainModel> InsertAsync(EmployeeDomainModel domainModel)
{
if (domainModel == null)
{
throw new ArgumentNullException(nameof(domainModel));
}
var model = ToModel <Employee, EmployeeDomainModel>(domainModel);
model = await _repository.InsertAsync(model).ConfigureAwait(false);
domainModel = ToModel <EmployeeDomainModel, Employee>(model);
return(domainModel);
}
/// <summary>
/// Called when we click on edit button, it renders employee record by Id using Partial view
/// </summary>
/// <param name="EmployeeId"></param>
/// <returns></returns>
public ActionResult AddEditEmployee(int EmployeeId)
{
List <DepartmentDomainModel> list = departmentBusiness.GetAllDepartment();
ViewBag.DepartmentList = new SelectList(list, "DepartmentId", "DepartmentName");
EmployeeViewModel model = new EmployeeViewModel();
EmployeeDomainModel empDomainModel = new EmployeeDomainModel();
if (EmployeeId > 0)
{
empDomainModel = empBusiness.GetEmployeeById(EmployeeId);
AutoMapper.Mapper.Map(empDomainModel, model);
}
return(PartialView("Partial2", model));
}
public string AddEditEmployee()
{
string result = "";
EmployeeViewModel vm = new EmployeeViewModel();
vm.EmployeeID = 13;
vm.Name = "Shovon";
vm.Address = "Khulna";
vm.DepartmentId = 2;
EmployeeDomainModel empDomainModel = new EmployeeDomainModel();
AutoMapper.Mapper.Map(vm, empDomainModel);
result = empBusiness.AddUpdateEmployee(empDomainModel);
return(result);
}
public string AddEditEmployee()
{
string result = "";
EmployeeViewModel employeeViewModel = new EmployeeViewModel
{
EmployeeID = 1030,
Address = "Comuna 13",
Name = "Jose",
DepartmentId = 1
};
EmployeeDomainModel employeeDomainModel = new EmployeeDomainModel();
AutoMapper.Mapper.Map(employeeViewModel, employeeDomainModel);
result = _employeeBusiness.AddUpdateEmployee(employeeDomainModel);
return(result);
}
public async Task <EmployeeDomainModel> GetEmployeeById(int id)
{
EmployeeDomainModel employee = new EmployeeDomainModel();
var model = await employeeRepository.SingleOrDefault(e => e.emp_id == id);
if (model != null)
{
employee.emp_id = model.emp_id;
employee.name = model.name;
employee.contact = model.contact;
employee.address = model.address;
employee.NIC = model.NIC;
employee.salary = model.salary;
employee.date = model.date;
}
return(employee);
}
public string AddEditEmployee()
{
string result = "";
EmployeeViewModel vm = new EmployeeViewModel();
vm.EmployeeId = 2014;
vm.Name = "Laura";
vm.DepartmentId = 3;
vm.Address = "Australia";
EmployeeDomainModel empDomainModel = new EmployeeDomainModel();
AutoMapper.Mapper.Map(vm, empDomainModel);
result = empBusiness.AddUpdateEmployee(empDomainModel);
return(result);
}
private bool CalculateDiscount(EmployeeDomainModel model, string firstName)
{
var discountApplied = false;
model.YearlyWage = 2000 * 26;
model.TotalDeductions = 1000;
discountApplied = firstName.StartsWith('A');
if (discountApplied)
{
var discount = model.YearlyWage / 10;
model.TotalDeductions = model.TotalDeductions + discount;
}
model.FinalWage = model.YearlyWage - model.TotalDeductions;
return(discountApplied);
}
public ActionResult Index(EmployeeViewModel model)
{
try
{
List <DepartmentDomainModel> list = departmentBusiness.GetAllDepartment();
ViewBag.DepartmentList = new SelectList(list, "DepartmentId", "DepartmentName");
EmployeeDomainModel empDomain = new EmployeeDomainModel();
AutoMapper.Mapper.Map(model, empDomain);
empDomain = empBusiness.AddEditEmployee(empDomain);
AutoMapper.Mapper.Map(empDomain, model);
return(View(model));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <string> AddUpdateEmployee(EmployeeDomainModel employee)
{
string status = "";
if (employee.emp_id > 0)
{
tblEmployee employeeToUpdate = await employeeRepository.SingleOrDefault(e => e.emp_id == employee.emp_id);
if (employeeToUpdate != null)
{
employeeToUpdate.name = employee.name;
employeeToUpdate.contact = employee.contact;
employeeToUpdate.address = employee.address;
employeeToUpdate.NIC = employee.NIC;
employeeToUpdate.salary = employee.salary;
employeeToUpdate.date = employee.date;
await employeeRepository.Update(employeeToUpdate);
status = "updated";
}
}
else
{
tblEmployee employeeToAdd = new tblEmployee();
employeeToAdd.name = employee.name;
employeeToAdd.contact = employee.contact;
employeeToAdd.address = employee.address;
employeeToAdd.NIC = employee.NIC;
employeeToAdd.salary = employee.salary;
employeeToAdd.date = employee.date;
await employeeRepository.Insert(employeeToAdd);
status = "added";
}
return(status);
}
public int InsertEmployee(EmployeeDomainModel employee)
{
return(DAL.InsertEmployee(employee));
}
