public IActionResult PutDepartmentEmployee(
string departmentNumber,
int employeeNumber,
[FromBody] DepartmentEmployeeModel department
)
{
DepartmentEmployee departmentToUpdate = new DepartmentEmployee
{
EmployeeNumber = employeeNumber,
DepartmentNumber = departmentNumber,
FromDate = department.FromDate,
ToDate = department.ToDate
};
_departmentEmployeeService.UpdateDepartmentEmployee(departmentToUpdate);
DepartmentEmployeeModel updatedDepartment = new DepartmentEmployeeModel
{
EmployeeNumber = departmentToUpdate.EmployeeNumber,
DepartmentNumber = departmentToUpdate.DepartmentNumber,
FromDate = departmentToUpdate.FromDate,
ToDate = departmentToUpdate.ToDate
};
return(Ok(updatedDepartment));
}
public async Task <IActionResult> AssignEmployeeDepartments([FromBody] EmployeeDepartmentViewModel vm)
{
var response = new ResposeViewModel();
try
{
foreach (var deptId in vm.DepartmentIds)
{
var ed = new DepartmentEmployeeModel()
{
DepartmentId = deptId,
EmployeeId = vm.EmployeeId,
AssignedDate = DateTime.UtcNow,
IsActive = true
};
_departmentContext.Add(ed);
await _departmentContext.SaveChangesAsync();
}
response.IsSuccess = true;
}
catch (Exception ex)
{
response.Message = ex.ToString();
}
return(Ok(response));
}
public ActionResult Index(DepartmentEmployeeModel model)
{
var client = new EmployeeServiceClient();
var departments = client.GetDepartments(model.StartDate, model.EndDate, model.Name).ToList();
model.Items = departments;
return(View(model));
}
public IActionResult GetAllDepartmentEmployeesByEmployeeNumber(
[FromQuery(Name = "page")] int page,
[FromQuery(Name = "pageSize")] int pageSize,
[FromQuery(Name = "sort")] string sort,
[FromQuery(Name = "filter")] string filter,
[FromQuery(Name = "currentlyEmployed")] bool currentlyEmployed,
int employeeNumber
)
{
page = (page <= 0) ? Constants.PageDefaultOffset : page;
pageSize = (pageSize <= 0) ? Constants.PageDefaultLimit : pageSize;
sort = sort ?? Constants.PageDefaultSort;
filter = filter ?? Constants.DepartmentEmplyoeeDefaultFilter;
List <DepartmentEmployeeModel> departmentList = new List <DepartmentEmployeeModel>();
_departmentEmployeeService.GetDepartmentEmployeeByEmployeeNumber(employeeNumber)
.Where(e =>
{
if (currentlyEmployed)
{
return(e.ToDate.Equals(Constants.DatabaseDefaultDate));
}
else
{
return(true);
}
})
.AsQueryable()
.OrderByDynamic(filter, sort)
.Skip(page * pageSize)
.Take(pageSize)
.ToList()
.ForEach(d =>
{
DepartmentEmployeeModel department = new DepartmentEmployeeModel
{
EmployeeNumber = d.EmployeeNumber,
DepartmentNumber = d.DepartmentNumber,
FromDate = d.FromDate,
ToDate = d.ToDate,
Department = d.Department
};
departmentList.Add(department);
});
if (departmentList.Count <= 0)
{
return(NoContent());
}
return(Ok(departmentList));
}
public ActionResult Employee(string id)
{
var model = new DepartmentEmployeeModel();
if (!string.IsNullOrEmpty(id))
{
var departmentID = short.Parse(id);
if (departmentID > 0)
{
var client = new EmployeeServiceClient();
var departments = client.GetEmployeesByDepartmentID(departmentID).ToList();
model.Items = departments;
}
}
return(View(model));
}
public IActionResult PostDepartmentEmployee(
[FromBody] DepartmentEmployeeModel departmentEmployee
)
{
try
{
_departmentEmployeeService.InsertDepartmentEmployee(
new DepartmentEmployee
{
EmployeeNumber = departmentEmployee.EmployeeNumber,
DepartmentNumber = departmentEmployee.DepartmentNumber,
FromDate = departmentEmployee.FromDate,
ToDate = departmentEmployee.ToDate
});
return(Created($"/api/departments/{departmentEmployee.DepartmentNumber}/employees/{departmentEmployee.EmployeeNumber}", departmentEmployee));
}
catch (GenericServiceException genericServiceException)
{
if (genericServiceException.GenericExceptionResponse.Equals(GenericExceptionResponse.ConflictException))
{
return(StatusCode(genericServiceException.StatusCode, APIResponse.ApiConflict(genericServiceException.Message)));
}
else if (genericServiceException.GenericExceptionResponse.Equals(GenericExceptionResponse.BadConstraintsException))
{
return(StatusCode(genericServiceException.StatusCode, APIResponse.BadRequest()));
}
else if (genericServiceException.GenericExceptionResponse.Equals(GenericExceptionResponse.InternalErrorException))
{
return(StatusCode(500, APIResponse.DefaultErrorMessage(genericServiceException.Message, 500)));
}
return(StatusCode(500, APIResponse.DefaultErrorMessage(genericServiceException.Message, 500)));
}
catch (Exception ex)
{
return(StatusCode(500, APIResponse.DefaultErrorMessage(ex.Message, 500)));
}
}
public IActionResult Index(bool groupByDepartment = true)
{
var model = new DepartmentEmployeeModel
{
GroupByDepartment = groupByDepartment
};
var employesModel = new EmployeesListModel {
Department = new DepartmentModel {
Name = ""
}
};
var emailCount = new Dictionary <string, int>(StringComparer.InvariantCultureIgnoreCase);
foreach (var d in _employeeService.GetOrderedDepartments(showUnpublished: false))
{
if (groupByDepartment)
{
employesModel = new EmployeesListModel {
Department = d.ToModel()
};
}
foreach (var employee in _employeeService.GetEmployeesByDepartmentId(d.Id, showUnpublished: false))
{
var e = employee.ToModel();
if (emailCount.ContainsKey(e.Email))
{
emailCount[e.Email]++;
}
else
{
emailCount[e.Email] = 1;
}
e.PhotoUrl = GetPictureUrl(e.PictureId);
e.DepartmentPublished = d.Published;
e.DepartmentName = d.Name;
employesModel.Employees.Add(e);
}
if (groupByDepartment)
{
// The Model is a list of departments each with a list of employees
model.EmployeesList.Add(employesModel);
}
}
if (!groupByDepartment)
{
// The Model is a single-entry list (empty department) with a list of all employees
model.EmployeesList.Add(employesModel);
}
foreach (var employeeList in model.EmployeesList)
{
foreach (var employee in employeeList.Employees)
{
employee.HasUniqueEmail = emailCount[employee.Email] == 1;
}
}
if (_permissionService.Authorize(EmployeePermissionProvider.ManageEmployees))
{
DisplayEditLink(Url.Action(nameof(List), ControllerName, new { area = "Admin" }));
}
return(View($"{Route}{nameof(Index)}.cshtml", model));
}
