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);
}
private async Task <DepartmentInfo[]> GetDepartments()
{
var departmentsResponse = await this.organizationActor.Ask <DepartmentsQuery.Response>(
DepartmentsQuery.Create());
return(departmentsResponse.Departments
.Select(d => d.Department)
.ToArray());
}
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));
}
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);
}
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);
}