public async Task <IActionResult> ListDepartments([FromQuery] DepartmentsQuery request)
{
try
{
var result = await _service.GetDepartments(request);
return(Ok(result));
}
catch (BusinessLogicException ex)
{
return(BadRequest(new Response
{
Status = false,
Message = ex.Message
}));
}
catch (Exception e)
{
return(BadRequest(new Response
{
Status = false,
Message = ErrorMessages.UnkownError
}));
}
}
public DepartmentsSearch(DepartmentsQuery departmentsQuery, IReadOnlyDictionary <string, IActorRef> departments, IActorRef requestor)
{
this.departmentsQuery = departmentsQuery;
this.departments = departments;
this.requestor = requestor;
this.Self.Tell(new StartSearch());
}
private UntypedReceive GetOwnDepartments(EmployeeMetadata employee)
{
void OnMessage(object message)
{
switch (message)
{
case DepartmentsQuery.Response response:
BulkBumpPermissions(
response.Departments.Select(x => x.Department.DepartmentId),
OwnDepartmentPermissions,
this.permissionsForDepartments);
this.Become(this.LoadSupervisedDepartmentsPermissions(employee.EmployeeId));
break;
case ReceiveTimeout _:
this.ReplyAndStop();
break;
default:
this.Unhandled(message);
break;
}
}
this.organizationActor.Tell(DepartmentsQuery.Create().WithId(employee.DepartmentId));
return(OnMessage);
}
private UntypedReceive LoadSupervisedDepartmentsPermissions(string employeeId)
{
void OnMessage(object message)
{
switch (message)
{
case DepartmentsQuery.Response r when r.Departments.Count == 0:
case ReceiveTimeout _:
this.ReplyAndStop();
break;
case DepartmentsQuery.Response response:
BulkBumpPermissions(
response.Departments.Select(x => x.Department.DepartmentId),
SupervisedPermissions,
this.permissionsForDepartments);
this.ReplyAndStop();
break;
default:
this.Unhandled(message);
break;
}
}
var departmentsQuery = DepartmentsQuery.Create()
.WithHead(employeeId)
.IncludeAllDescendants();
this.organizationActor.Tell(departmentsQuery);
return(OnMessage);
}
protected override void OnReceive(object message)
{
switch (message)
{
case StartSearch:
foreach (var actorRef in this.employeeActorsToReply)
{
actorRef.Tell(EmployeeActor.GetEmployeeInfo.Instance);
}
if ((this.requesters.Count == 0) || (this.employeeActorsToReply.Count == 0))
{
this.Self.Tell(SearchFinished);
}
else
{
if (this.query.AscendantDepartmentId != null)
{
var departmentQuery = new DepartmentsQuery();
//TODO: work in progress
}
}
break;
case EmployeeActor.GetEmployeeInfo.Response response:
if (this.CheckFilter(response.Employee.Metadata))
{
this.results.Add(response.Employee);
}
this.employeeActorsToReply.Remove(response.Employee.Actor);
if (this.employeeActorsToReply.Count == 0)
{
this.Self.Tell(SearchFinished);
}
break;
case SearchFinished:
foreach (var requester in this.requesters)
{
requester.Tell(new EmployeesQuery.Response(this.results));
}
Context.Stop(this.Self);
break;
default:
this.Unhandled(message);
break;
}
}
private async Task <DepartmentInfo[]> GetDepartments()
{
var departmentsResponse = await this.organizationActor.Ask <DepartmentsQuery.Response>(
DepartmentsQuery.Create());
return(departmentsResponse.Departments
.Select(d => d.Department)
.ToArray());
}
private static void Test11Helper(uint start, uint stop, bool[] isInfExpected,
bool[] isVisited, uint[][][] stampsExpected, Departments dps)
{
for (uint i = start; i < stop; ++i)
{
DepartmentsQuery expected = new DepartmentsQuery(isInfExpected[i],
isVisited[i], stampsExpected[i]);
if (!expected.EqualTo(dps.Query(i + 1)))
{
isTest11Correct = false;
}
}
}
private static void MyTestHelper(bool[] isInfExpected, bool[] isVisited, uint[][][] stampsExpected, Departments dps, uint n)
{
bool tmp = true;
for (uint i = 0; i < n; ++i)
{
DepartmentsQuery expected = new DepartmentsQuery(isInfExpected[i], isVisited[i], stampsExpected[i]);
tmp = tmp && expected.EqualTo(dps.Query(i + 1));
if (tmp == false)
{
break;
}
}
Assert.True(tmp);
}
public DepartmentsSearch(IActorRef searchRootDepartment, IEnumerable <IActorRef> requesters, DepartmentsQuery query)
{
this.query = query;
this.requesters = new HashSet <IActorRef>(requesters);
this.actorsToReply.Add(searchRootDepartment);
if (this.requesters.Count == 0)
{
Context.Stop(this.Self);
}
this.Self.Tell(StartSearch.Instance);
}
private async Task <IEnumerable <IActorRef> > GetUserFeeds(EmployeeContainer employee, CancellationToken token)
{
var feedsActor = this.actorFactory.ActorSelection(this.pathsBuilder.Get(WellKnownActorPaths.SharedFeeds));
var sharedFeedsResponse =
await feedsActor.Ask <GetFeeds.Response>(new GetFeeds(employee.Metadata.EmployeeId), this.timeoutSettings.Timeout, token);
var sharedFeeds = sharedFeedsResponse.Feeds.Values;
var departmentActor = this.actorFactory.ActorSelection(this.pathsBuilder.Get(WellKnownActorPaths.Organization));
var department =
await departmentActor.Ask <DepartmentsQuery.Response>(DepartmentsQuery.Create().WithId(employee.Metadata.DepartmentId));
var departmentFeeds = department.Departments.Select(x => x.Feed);
return(sharedFeeds.Union(departmentFeeds));
}
public void Test1()
{
uint n = 1, m = 1, a = 1, z = 1;
SimpleDepartment[] deps = new SimpleDepartment[n];
deps[0] = new SimpleDepartment(1, 0, 1);
Departments dps = new Departments(n, m, a, z, deps);
bool isInfExpected = false;
bool isVisited = true;
uint[][] stampsExpected = new uint[0][];
DepartmentsQuery expected = new DepartmentsQuery(isInfExpected, isVisited, stampsExpected);
Assert.True(expected.EqualTo(dps.Query(1)));
}
public async Task <Response <DepartmentsDto> > GetDepartments(DepartmentsQuery request)
{
var result = _context.Departments.AsQueryable();
if (!string.IsNullOrEmpty(request.Name))
{
result = result.Where(x => x.Name.Contains(request.Name));
}
///pagenating
int take = request.PageSize;
int skip = (request.PageId - 1) * take;
int totalPages = (int)Math.Ceiling(result.Count() / (double)take);
var finalResult = result.OrderBy(x => x.Name).Skip(skip).Take(take).AsQueryable();
//----------------
var resultData = new DepartmentsDto
{
Dtos = await finalResult.Select(d => new DepartmentDto()
{
Id = d.Id,
Name = d.Name
}).ToListAsync(),
PageId = request.PageId,
PageSize = request.PageSize,
Total = await result.CountAsync()
};
return(new Response <DepartmentsDto>
{
Data = resultData,
Status = true,
Message = "success"
});
}
private UntypedReceive LoadSupervisedDepartmentsPermissions(string employeeId)
{
void OnMessage(object message)
{
switch (message)
{
case DepartmentsQuery.Response r when r.Departments.Count == 0:
case ReceiveTimeout _:
this.ReplyAndStop();
break;
case DepartmentsQuery.Response response:
//setup permissions for directly supervised departments
BulkBumpPermissions(response.Departments.Select(x => x.Department.DepartmentId), SupervisedPermissions, this.permissionsForDepartments);
var tasks = response
.Departments
.Select(x => this.organizationActor.Ask <DepartmentsQuery.Response>(DepartmentsQuery.Create().DescendantOf(x.Department.DepartmentId), this.timeout));
//setup permissions for branch-like supervised departments
Task.WhenAll(tasks).PipeTo(this.Self);
break;
//child departments
case DepartmentsQuery.Response[] responses:
var departmentsIds = responses.SelectMany(r => r.Departments.Select(d => d.Department.DepartmentId));
BulkBumpPermissions(departmentsIds, SupervisedPermissions, this.permissionsForDepartments);
this.ReplyAndStop();
break;
default:
this.Unhandled(message);
break;
}
}
this.organizationActor.Tell(DepartmentsQuery.Create().WithHead(employeeId));
return(OnMessage);
}
//[Authorize(Roles = "user")]
public async Task <IEnumerable <DepartmentDto> > Departments([FromQuery] DepartmentsQuery departmentQuery)
{
return(await _mediator.Send(departmentQuery));
}
public Task <IEnumerable <DepartmentDto> > Handle(DepartmentsQuery request, CancellationToken cancellationToken)
{
var departments = _departmentDomain.GetAll();
return(Task.FromResult(departments.MapTo <IEnumerable <DepartmentDto> >()));
}
private UntypedReceive GatherEmployeeInfo(
EmployeeMetadata approver,
DependentDepartmentsPendingActions dependentDepartmentsPendingActions)
{
this.organization.Tell(
DepartmentsQuery.Create()
.WithHead(approver.EmployeeId)
.IncludeDirectDescendants());
void OnMessage(object message)
{
switch (message)
{
case DepartmentsQuery.Response response when response.Departments.Count == 0:
this.FinishProcessing();
break;
case DepartmentsQuery.Response response:
var ownDepartmentsEmployees = response.Departments
.Where(d => d.Department.ChiefId == approver.EmployeeId)
.SelectMany(d => d.Employees);
var otherDepartmentsEmployees = response.Departments
.Where(d => d.Department.ChiefId != approver.EmployeeId)
.Select(d => new
{
d.Department.ChiefId,
Employees = d.Employees.Where(e =>
{
if (dependentDepartmentsPendingActions == DependentDepartmentsPendingActions.All)
{
return(true);
}
if (dependentDepartmentsPendingActions == DependentDepartmentsPendingActions.HeadsOnly)
{
return(e.Metadata.EmployeeId == d.Department.ChiefId);
}
return(false);
})
})
.SelectMany(x => x.Employees);
var subordinates = ownDepartmentsEmployees
.Union(otherDepartmentsEmployees)
.GroupBy(x => x.Metadata.EmployeeId)
.Select(x => x.First())
.ToList();
if (subordinates.Count == 0)
{
this.FinishProcessing();
}
this.Become(this.GatherCalendarEvents(subordinates));
break;
default:
this.DefaultMessageHandler(message);
break;
}
}
return(OnMessage);
}