public IActionResult GetReportingStructureDataByEmployeeId(String id)
{
// find employee record
_logger.LogDebug($"Received reporting structure get request for employee '{id}'");
var employee = _employeeService.GetById(id);
if (employee == null)
{
return(NotFound());
}
// create ReportingStructure data from found employee record
ReportingStructure rs = new ReportingStructure();
rs.employee = employee;
if (rs.employee.DirectReports == null)
{
rs.numberOfReports = 0;
}
else
{
List <Employee> allDirectReportsToEmployeeInTree = IEmumerationUtilities.Traverse(rs.employee).ToList();
rs.numberOfReports = allDirectReportsToEmployeeInTree.Count - 1; // subtract the root node from the count
}
// return the reporting structure data object
return(Ok(rs));
}
public IActionResult GetReportStructureByEmployeeId(string id)
{
_logger.LogDebug($"Received report structure get request for '{id}'");
var employee = _employeeService.GetById(id);
if (employee == null)
{
return(NotFound());
}
// DFS can be used instead of this.
Stack <Employee> dirs = new Stack <Employee>();
var noOfReports = new List <string>();
if (employee.DirectReports != null)
{
foreach (var dir in employee.DirectReports)
{
dirs.Push(dir);
}
while (dirs.Count > 0)
{
var currEmployee = dirs.Pop();
noOfReports.Add(currEmployee.EmployeeId);
var sub = _employeeService.GetById(currEmployee.EmployeeId);
if (sub != null)
{
var subDirs = sub.DirectReports;
if (subDirs != null)
{
foreach (var subDir in subDirs)
{
dirs.Push(subDir);
}
}
}
}
}
var reportStructure = new ReportingStructure()
{
employee = employee,
numberOfReports = noOfReports.Count
};
return(Ok(reportStructure));
}
public IActionResult DirectReportsToEmployee(String id, ReportingStructure newRepStruct)
{
_logger.LogDebug($"Recieved employee update request for '{id}'");
var existingEmployee = _employeeService.GetById(id);
if (existingEmployee == null)
{
return(NotFound());
}
return(Ok(newRepStruct));
}
public async Task <IActionResult> GetReportingStructureByEmployeeById(String id, CancellationToken cancellationToken)
{
_logger.LogDebug($"Received employee reporting structure request request for '{id}'");
ReportingStructure reportingStructure = await _employeeService.GetReportingStructureForEmployee(id, cancellationToken);
if (reportingStructure == null)
{
return(NotFound());
}
return(Ok(reportingStructure));
}
public IActionResult GetReportsById(String id)
{
_logger.LogDebug($"Received report get request for '{id}'");
ReportingStructure reports = _reportingStructureService.GetReportsById(id);
if (reports == null)
{
return(NotFound());
}
return(Ok(reports));
}
public IActionResult GetReportingStructureById(String id)
{
_logger.LogDebug($"Received reporting structure request for '{id}'");
var employee = _employeeService.GetById(id);
int count = 0;
ReportingStructure return_ReportingStructure;
if (employee == null)
{
return(NotFound());
}
else
{
Queue <Employee> structureQueue = new Queue <Employee>();
if ((employee.DirectReports != null) && (employee.DirectReports.Any()))
{
foreach (Employee reporting_Employee in employee.DirectReports)
{
structureQueue.Enqueue(reporting_Employee);
}
while (structureQueue.Count != 0)
{
var next_Employee = structureQueue.Dequeue();
count++;
if ((next_Employee.DirectReports != null) && (next_Employee.DirectReports.Any()))
{
foreach (Employee reporting_Employee in next_Employee.DirectReports)
{
structureQueue.Enqueue(reporting_Employee);
}
}
}
return_ReportingStructure = new ReportingStructure()
{
Employee = employee,
NumberOfReports = count
};
return(Ok(return_ReportingStructure));
}
else
{
return_ReportingStructure = new ReportingStructure()
{
Employee = employee,
NumberOfReports = count
};
return(Ok(return_ReportingStructure));
}
}
}
public IActionResult GetReportingStructureByEmployeeId(String employeeId)
{
_logger.LogDebug($"Received reporting structure get request for '{employeeId}'");
var employee = _employeeService.GetById(employeeId);
if (employee == null)
{
return(NotFound());
}
var reportingStructure = new ReportingStructure(employee);
return(Ok(reportingStructure));
}
public ReportingStructure reportingStructure(String id)
{
var employee = _employeeService.GetById(id);
var totalReports = employee.DirectReports.Count;
List <Employee> DirectReports = employee.DirectReports;
foreach (Employee reportingEmployee in DirectReports)
{
totalReports += ReportingEmployee(reportingEmployee); //calls method to calculate all directly reporting employees
}
ReportingStructure reportStructure = new ReportingStructure();
reportStructure.employee = employee;
reportStructure.numberOfReports = totalReports;
return(reportStructure);
}
public IActionResult GetEmployeeById(String id)
{
_logger.LogDebug($"Received Reporting Structure get request for '{id}'");
var employee = _employeeService.GetById(id);
_directReports = 0;
recursiveCount(employee.DirectReports);
var reportingStructure = new ReportingStructure(_directReports, employee);
if (employee == null)
{
return(NotFound());
}
return(Ok(reportingStructure));
}
public IActionResult GetEmployeeReportingStructure(String employeeId)
{
_logger.LogDebug($"Recieved employee reporting structure request for '{employeeId}");
var employee = _employeeService.GetById(employeeId, true);
if (employee == null)
{
return(NotFound());
}
// Create reporting structure
ReportingStructure reportingStructure = new ReportingStructure()
{
Employee = employee,
NumberOfReports = employee.DirectReports.Count + employee.DirectReports.Sum(r => r.DirectReports.Count())
};
return(Ok(reportingStructure));
}
public IActionResult Get(String id)
{
_logger.LogDebug($"Received Reporting get request for '{id}'");
//Get the it's current employee object
var employeeFromService = _employeeService.GetById(id);
//Check if it exists
if (employeeFromService == null)
{
return(NotFound());
}
//Fill in the contents
ReportingStructure resultReport = new ReportingStructure()
{
employee = employeeFromService,
numberOfReports = _employeeService.GetCountOfReports(id)
};
return(Ok(resultReport));
}
public IActionResult getNumberOfReportsById(String id)
{
// TODO: Can we add validation for negative salary? Need to check requirements
_logger.LogDebug($"Received employee reporting structure get request for '{id}'");
var employee = _employeeService.GetById(id);
if (employee == null)
{
return(NotFound());
}
try
{
var reportingStructure = new ReportingStructure()
{
Employee = employee,
NumberOfReports = RecursiveCountReports(id, new List <Employee>()
{
employee
})
};
return(Ok(reportingStructure));
}
catch (Exception ex)
{
_logger.LogError($"Error: {ex.Message}");
return(NoContent());
}
//-----------------------------------------------------------------------------------------------------
// inline functions
int RecursiveCountReports(string employeeId, List <Employee> directReports)
{
var emp = _employeeService.GetById(employeeId);
var reports = emp.DirectReports;
if (reports is null)
{
return(0);
}
var returnValue = reports.Count;
foreach (var report in reports)
{
// Check if we already have someone by the same employee id in the list of direct reports, if so error
if (directReports.Any(x => x.EmployeeId == report.EmployeeId))
{
throw new OperationCanceledException($"Circular reference detected, cancelling operation; employeeId: {report.EmployeeId}");
}
if (report.DirectReports is null)
{
continue;
}
returnValue += RecursiveCountReports(report.EmployeeId, directReports);
}
return(returnValue);
}
}
