public EmployeeActor(
            EmployeeStoredInformation storedInformation,
            IActorRef imageResizer,
            IActorRef vacationsCreditRegistry,
            IEmployeeVacationsRegistryPropsFactory employeeVacationsRegistryPropsFactory,
            IEmployeeSickLeavesRegistryPropsFactory employeeSickLeavesRegistryPropsFactory)
        {
            this.employeeMetadata = storedInformation.Metadata;
            this.PersistenceId    = $"employee-info-{Uri.EscapeDataString(this.employeeMetadata.EmployeeId)}";

            this.photo = Context.ActorOf(Props.Create(() => new PhotoActor(imageResizer)), "photo");
            this.photo.Tell(new PhotoActor.SetSource(storedInformation.Photo));

            this.employeeFeed = Context.ActorOf(FeedActor.GetProps(), "feed");

            var persistenceSupervisorFactory = new PersistenceSupervisorFactory();

            var vacationActorProps = EmployeeVacationsActor.CreateProps(
                this.employeeMetadata.EmployeeId,
                this.employeeFeed,
                vacationsCreditRegistry,
                employeeVacationsRegistryPropsFactory);

            var sickLeaveActorProps = EmployeeSickLeaveActor.CreateProps(
                this.employeeMetadata.EmployeeId,
                employeeSickLeavesRegistryPropsFactory);

            var workHoursActorProps = EmployeeWorkHoursActor.CreateProps(this.employeeMetadata.EmployeeId);

            var vacationsActor = Context.ActorOf(vacationActorProps, "vacations");

            var sickLeavesActor = Context.ActorOf(sickLeaveActorProps, "sick-leaves");

            var workHoursActor = Context.ActorOf(
                persistenceSupervisorFactory.Get(workHoursActorProps),
                "work-hours");

            var calendarActor = Context.ActorOf(
                EmployeeCalendarActor.CreateProps(
                    this.employeeMetadata.EmployeeId,
                    vacationsActor,
                    workHoursActor,
                    sickLeavesActor),
                "all-calendar-events"
                );

            var pendingActionsActor = Context.ActorOf(
                EmployeePendingActionsActor.CreateProps(this.employeeMetadata.EmployeeId),
                "pending-actions"
                );

            this.calendar = new EmployeeCalendarContainer(
                vacationsActor,
                workHoursActor,
                sickLeavesActor,
                calendarActor,
                pendingActionsActor);
        }
예제 #2
0
        public EmployeeSickLeaveActor(
            string employeeId,
            IEmployeeSickLeavesRegistryPropsFactory sickLeavesRegistryPropsFactory)
        {
            var persistenceSupervisorFactory = new PersistenceSupervisorFactory();

            var sickLeavesRegistryProps = sickLeavesRegistryPropsFactory.CreateProps(employeeId);

            this.sickLeavesRegistry = Context.ActorOf(
                persistenceSupervisorFactory.Get(sickLeavesRegistryProps),
                "sick-leaves-registry");
        }
예제 #3
0
        public ServerActorsCollection AddRootActors(
            ICalendarEventsMailSettings calendarEventsMailSettings,
            ICalendarEventsPushSettings calendarEventsPushSettings,
            IImapSettings imapSettings)
        {
            var organization = this.actorSystem.ActorOf(this.actorSystem.DI().Props <OrganizationActor>(), WellKnownActorPaths.Organization);
            var health       = this.actorSystem.ActorOf(this.actorSystem.DI().Props <HealthChecker>(), WellKnownActorPaths.Health);
            var helpdesk     = this.actorSystem.ActorOf(Props.Create(() => new HelpdeskActor()), WellKnownActorPaths.Helpdesk);
            var feeds        = this.actorSystem.ActorOf(Props.Create(() => new SharedFeedsActor(organization)), WellKnownActorPaths.SharedFeeds);

            this.actorSystem.ActorOf(Props.Create(() => new ApplicationBuildsActor()), WellKnownActorPaths.ApplicationBuilds);

            var persistenceSupervisorFactory = new PersistenceSupervisorFactory();

            var userPreferenceActorProps = this.actorSystem.DI().Props <UserPreferencesActor>();
            var userPreferences          = this.actorSystem.ActorOf(
                persistenceSupervisorFactory.Get(userPreferenceActorProps),
                WellKnownActorPaths.UserPreferences);

            var pushNotificationsDevicesActorProps = PushNotificationsDevicesActor.CreateProps();
            var pushNotificationsDevices           = this.actorSystem.ActorOf(
                persistenceSupervisorFactory.Get(pushNotificationsDevicesActorProps),
                WellKnownActorPaths.PushNotificationsDevices);

            var inboxEmailsActor = this.actorSystem.ActorOf(this.actorSystem.DI().Props <InboxEmailActor>(), "inbox-emails");

            this.actorSystem.ActorOf(Props.Create(() => new InboxEmailsNotificator(imapSettings, inboxEmailsActor)), "emails-notificator");

            this.CreateCalendarEventNotificationActors(
                calendarEventsMailSettings,
                calendarEventsPushSettings,
                organization,
                userPreferences,
                pushNotificationsDevices);

            var emailNotificationsActorProps = this.actorSystem.DI().Props <EmailNotificationsActor>();
            var pushNotificationsActorProps  = this.actorSystem.DI().Props <PushNotificationsActor>();

            this.actorSystem.ActorOf(
                Props.Create(() => new NotificationsDispatcherActor(emailNotificationsActorProps, pushNotificationsActorProps)),
                WellKnownActorPaths.Notifications);

            this.actorSystem.ActorOf(this.actorSystem.DI().Props <CalendarEventsApprovalsChecker>(), "calendar-events-approvals");

            return(new ServerActorsCollection(organization, health, helpdesk, feeds, userPreferences, pushNotificationsDevices));
        }
        private void RecreateEmployeeAgents(IReadOnlyCollection <EmployeeStoredInformation> allEmployees)
        {
            this.logger.Debug("Recreating employee agents...");
            var removedIds = this.employeesById.Keys.Except(allEmployees.Select(x => x.Metadata.EmployeeId)).ToList();

            foreach (var removedId in removedIds)
            {
                this.employeesById.Remove(removedId);
            }

            var persistenceSupervisorFactory = new PersistenceSupervisorFactory();

            var newEmployeesCount = 0;

            foreach (var employeeNewInfo in allEmployees)
            {
                IActorRef employeeActor;
                var       employeeId = employeeNewInfo.Metadata.EmployeeId;

                if (this.employeesById.TryGetValue(employeeId, out var employee))
                {
                    employeeActor = employee.EmployeeActor;
                    employeeActor.Tell(new EmployeeActor.UpdateEmployeeInformation(employeeNewInfo));
                }
                else
                {
                    var employeeActorProps = EmployeeActor.GetProps(
                        employeeNewInfo,
                        this.imageResizer,
                        this.vacationsCreditRegistry,
                        this.employeeVacationsRegistryPropsFactory,
                        this.employeeSickLeavesRegistryPropsFactory);
                    employeeActor = Context.ActorOf(
                        persistenceSupervisorFactory.Get(employeeActorProps),
                        $"employee-{Uri.EscapeDataString(employeeId)}");

                    newEmployeesCount++;
                }

                this.employeesById[employeeId] = new EmployeeIndexEntry(employeeActor, employeeNewInfo.Metadata);
            }

            this.logger.Debug($"Employees list is updated. There are {allEmployees.Count} at all, {removedIds.Count} got removed, {newEmployeesCount} were added");
        }
        public SharedFeedsActor(IActorRef organization)
        {
            var persistenceSupervisorFactory = new PersistenceSupervisorFactory();

            var newsFeedActorProps = PersistentFeedActor.CreateProps(NewsFeedId);
            var newsFeed           = Context.ActorOf(persistenceSupervisorFactory.Get(newsFeedActorProps), NewsFeedId);

            var systemFeedActorProps = PersistentFeedActor.CreateProps(SystemFeedId);
            var systemFeed           = Context.ActorOf(persistenceSupervisorFactory.Get(systemFeedActorProps), SystemFeedId);

            var birthdayFeed      = Context.ActorOf(EmployeesBirthdaysFeedActor.CreateProps(organization), BirthdaysFeedId);
            var anniversariesFeed = Context.ActorOf(EmployeesAnniversariesFeedActor.CreateProps(organization), AnniversariesFeedId);

            this.feedsById.Add(NewsFeedId, newsFeed);
            this.feedsById.Add(SystemFeedId, systemFeed);
            this.feedsById.Add(BirthdaysFeedId, birthdayFeed);
            this.feedsById.Add(AnniversariesFeedId, anniversariesFeed);

            // systemFeed.Tell(new PostMessage(new Message(Guid.NewGuid().ToString(), null, "System is up", "System has started", DateTime.UtcNow)));
        }
예제 #6
0
        public EmployeeVacationsActor(
            string employeeId,
            IActorRef employeeFeed,
            IActorRef vacationsCreditRegistry,
            IEmployeeVacationsRegistryPropsFactory vacationsRegistryPropsFactory
            )
        {
            this.employeeId              = employeeId;
            this.employeeFeed            = employeeFeed;
            this.vacationsCreditRegistry = vacationsCreditRegistry;

            this.calendarEventsApprovalsChecker = Context.ActorSelection(CalendarEventsApprovalsCheckerActorPath);

            var persistenceSupervisorFactory = new PersistenceSupervisorFactory();

            var vacationsRegistryProps = vacationsRegistryPropsFactory.CreateProps(employeeId);

            this.vacationsRegistry = Context.ActorOf(
                persistenceSupervisorFactory.Get(vacationsRegistryProps),
                "vacations-registry");

            Context.System.EventStream.Subscribe <CalendarEventChanged>(this.Self);
            Context.System.EventStream.Subscribe <CalendarEventRecoverComplete>(this.Self);
        }