private void ProcessRepositoryEvent(RepositoryMonitorEvent Event)
        {
            var device = (Device)Event.Entity;
            string previousUserId = Event.GetPreviousPropertyValue<string>("AssignedUserId");

            Event.ExecuteAfterCommit(e =>
            {
                switch (e.EventType)
                {
                    case RepositoryMonitorEventType.Added:
                        AddMember(device.AssignedUserId);
                        break;
                    case RepositoryMonitorEventType.Modified:
                        if (device.DeviceProfileId == this.DeviceProfileId)
                        {
                            if (device.AssignedUserId != null)
                                AddMember(device.AssignedUserId);

                            if (e.ModifiedProperties.Contains("AssignedUserId"))
                            {
                                if (previousUserId != null)
                                    RemoveMember(previousUserId, (database) =>
                                        !database.Devices.Any(d => d.DeviceProfileId == this.DeviceProfileId && d.AssignedUserId == previousUserId)
                                            ? new string[] { previousUserId }
                                            : null);
                            }
                        }
                        else
                        {
                            if (previousUserId != null)
                                RemoveMember(previousUserId, (database) =>
                                    !database.Devices.Any(d => d.DeviceProfileId == this.DeviceProfileId && d.AssignedUserId == previousUserId)
                                        ? new string[] { previousUserId }
                                        : null);
                        }
                        break;
                    case RepositoryMonitorEventType.Deleted:
                        if (previousUserId != null)
                            RemoveMember(previousUserId, (database) =>
                                !database.Devices.Any(d => d.DeviceProfileId == this.DeviceProfileId && d.AssignedUserId == previousUserId)
                                    ? new string[] { previousUserId }
                                    : null);
                        break;
                }
            });
        }
        private void ProcessDeviceAssignmentRepositoryEvent(RepositoryMonitorEvent Event)
        {
            var device = (Device)Event.Entity;
            var deviceSerialNumber = device.SerialNumber;
            var deviceAccountId = device.DeviceDomainId;

            if (ActiveDirectory.IsValidDomainAccountId(deviceAccountId))
            {
                var deviceCurrentAssignedUserId = device.AssignedUserId;
                var devicePreviousAssignedUserId = Event.GetPreviousPropertyValue<string>("AssignedUserId");

                Event.ExecuteAfterCommit(e =>
                {
                    bool previousUserHasTemplate = false;
                    bool currentUserHasTemplate = false;

                    if (devicePreviousAssignedUserId != null)
                    {
                        if (Configuration.FilterBeginDate.HasValue)
                        {
                            previousUserHasTemplate = e.Database.Users
                                .Where(u => u.UserId == devicePreviousAssignedUserId && u.UserAttachments.Any(ua => ua.DocumentTemplateId == this.DocumentTemplateId && ua.Timestamp >= Configuration.FilterBeginDate))
                                .Any();
                        }
                        else
                        {
                            previousUserHasTemplate = e.Database.Users
                                .Where(u => u.UserId == devicePreviousAssignedUserId && u.UserAttachments.Any(ua => ua.DocumentTemplateId == this.DocumentTemplateId))
                                .Any();
                        }
                    }

                    if (deviceCurrentAssignedUserId != null)
                    {
                        if (Configuration.FilterBeginDate.HasValue)
                        {
                            currentUserHasTemplate = e.Database.Users
                                .Where(u => u.UserId == deviceCurrentAssignedUserId && u.UserAttachments.Any(ua => ua.DocumentTemplateId == this.DocumentTemplateId && ua.Timestamp >= Configuration.FilterBeginDate))
                                .Any();
                        }
                        else
                        {
                            currentUserHasTemplate = e.Database.Users
                                .Where(u => u.UserId == deviceCurrentAssignedUserId && u.UserAttachments.Any(ua => ua.DocumentTemplateId == this.DocumentTemplateId))
                                .Any();
                        }
                    }

                    if (!previousUserHasTemplate && currentUserHasTemplate)
                        AddMember(deviceSerialNumber, (database) => new string[] { deviceAccountId + "$" });
                    else if (previousUserHasTemplate && !currentUserHasTemplate)
                        RemoveMember(deviceSerialNumber, (database) => new string[] { deviceAccountId + "$" });
                });
            }
        }
        private void ProcessDeviceRenameRepositoryEvent(RepositoryMonitorEvent Event)
        {
            var device = (Device)Event.Entity;
            var deviceSerialNumber = device.SerialNumber;
            var deviceAccountId = device.DeviceDomainId;
            var deviceAccountIdValid = ActiveDirectory.IsValidDomainAccountId(deviceAccountId);
            var devicePreviousAccountId = Event.GetPreviousPropertyValue<string>("DeviceDomainId");
            var devicePreviousAccountIdValid = ActiveDirectory.IsValidDomainAccountId(devicePreviousAccountId);

            if (deviceAccountIdValid || devicePreviousAccountIdValid)
            {
                Event.ExecuteAfterCommit(e =>
                {
                    switch (DocumentTemplateScope)
                    {
                        case DocumentTemplate.DocumentTemplateScopes.Device:
                            if (DeviceContainsAttachment(e.Database, device.SerialNumber, out deviceAccountId))
                            {
                                if (deviceAccountIdValid)
                                    AddMember(device.SerialNumber, (database) => new string[] { deviceAccountId });
                                if (devicePreviousAccountIdValid)
                                    RemoveMember(device.SerialNumber, (database) => new string[] { devicePreviousAccountId + "$" });
                            }
                            break;
                        case DocumentTemplate.DocumentTemplateScopes.Job:
                            bool jobsHaveTemplate;
                            if (Configuration.FilterBeginDate.HasValue)
                            {
                                jobsHaveTemplate = e.Database.Jobs
                                    .Where(j => j.DeviceSerialNumber == deviceSerialNumber)
                                    .Any(j => j.JobAttachments.Any(a => a.DocumentTemplateId == this.DocumentTemplateId && a.Timestamp >= Configuration.FilterBeginDate));
                            }
                            else
                            {
                                jobsHaveTemplate = e.Database.Jobs
                                    .Where(j => j.DeviceSerialNumber == deviceSerialNumber)
                                    .Any(j => j.JobAttachments.Any(a => a.DocumentTemplateId == this.DocumentTemplateId));
                            }

                            if (jobsHaveTemplate)
                            {
                                if (deviceAccountIdValid)
                                    AddMember(device.SerialNumber, (database) => new string[] { deviceAccountId + "$" });
                                if (devicePreviousAccountIdValid)
                                    RemoveMember(device.SerialNumber, (database) => new string[] { devicePreviousAccountId + "$" });
                            }
                            break;
                        case DocumentTemplate.DocumentTemplateScopes.User:
                            bool userHasTemplate;
                            if (Configuration.FilterBeginDate.HasValue)
                            {
                                userHasTemplate = e.Database.Devices
                                    .Where(d => d.SerialNumber == deviceSerialNumber)
                                    .Select(d => d.AssignedUser)
                                    .Any(u => u.UserAttachments.Any(a => a.DocumentTemplateId == this.DocumentTemplateId && a.Timestamp >= Configuration.FilterBeginDate));
                            }
                            else
                            {
                                userHasTemplate = e.Database.Devices
                                    .Where(d => d.SerialNumber == deviceSerialNumber)
                                    .Select(d => d.AssignedUser)
                                    .Any(u => u.UserAttachments.Any(a => a.DocumentTemplateId == this.DocumentTemplateId));
                            }

                            if (userHasTemplate)
                            {
                                if (deviceAccountIdValid)
                                    AddMember(device.SerialNumber, (database) => new string[] { deviceAccountId + "$" });
                                if (devicePreviousAccountIdValid)
                                    RemoveMember(device.SerialNumber, (database) => new string[] { devicePreviousAccountId + "$" });
                            }
                            break;
                    }
                });
            }
        }
        private void ProcessDeviceAssignmentRepositoryEvent(RepositoryMonitorEvent Event)
        {
            var device = (Device)Event.Entity;
            var deviceSerialNumber = device.SerialNumber;
            bool relevantDevice;

            if (Configuration.FilterBeginDate.HasValue)
            {
                relevantDevice = Event.Database.Devices
                    .Where(d => d.SerialNumber == deviceSerialNumber && d.DeviceAttachments.Any(ja => ja.DocumentTemplateId == this.DocumentTemplateId && ja.Timestamp >= Configuration.FilterBeginDate))
                    .Any();
            }
            else
            {
                relevantDevice = Event.Database.Devices
                    .Where(d => d.SerialNumber == deviceSerialNumber && d.DeviceAttachments.Any(ja => ja.DocumentTemplateId == this.DocumentTemplateId))
                    .Any();
            }

            if (relevantDevice)
            {
                var deviceCurrentAssignedUserId = device.AssignedUserId;
                var devicePreviousAssignedUserId = Event.GetPreviousPropertyValue<string>("AssignedUserId");

                Event.ExecuteAfterCommit(e =>
                {
                    if (devicePreviousAssignedUserId != null)
                        RemoveMember(devicePreviousAssignedUserId, (database) => new string[] { devicePreviousAssignedUserId });

                    if (deviceCurrentAssignedUserId != null)
                        AddMember(deviceCurrentAssignedUserId, (database) => new string[] { deviceCurrentAssignedUserId });
                });
            }
        }
示例#5
0
        private static void RepositoryEvent(RepositoryMonitorEvent i)
        {
            List<string> deviceSerialNumbers = new List<string>();
            List<string> userIds = new List<string>();

            if (i.EntityType == typeof(Job))
            {
                if (i.EventType == RepositoryMonitorEventType.Modified &&
                    i.ModifiedProperties.Contains("DeviceSerialNumber"))
                {
                    var p = i.GetPreviousPropertyValue<string>("DeviceSerialNumber");
                    if (p != null)
                        deviceSerialNumbers.Add(p);
                }

                var j = (Job)i.Entity;
                if (j.DeviceSerialNumber != null)
                    deviceSerialNumbers.Add(j.DeviceSerialNumber);
            }
            else if (i.EntityType == typeof(JobMetaNonWarranty))
            {
                var jmnw = (JobMetaNonWarranty)i.Entity;

                if (jmnw.Job != null)
                {
                    if (jmnw.Job.DeviceSerialNumber != null)
                        deviceSerialNumbers.Add(jmnw.Job.DeviceSerialNumber);
                }
                else
                {
                    var sn = i.Database.Jobs.Where(j => j.Id == jmnw.JobId).Select(j => j.DeviceSerialNumber).FirstOrDefault();
                    if (sn != null)
                        deviceSerialNumbers.Add(sn);
                }
            }
            else if (i.EntityType == typeof(Device))
            {
                var d = (Device)i.Entity;
                deviceSerialNumbers.Add(d.SerialNumber);

                if (i.EventType == RepositoryMonitorEventType.Modified &&
                    i.ModifiedProperties.Contains("AssignedUserId"))
                {
                    var p = i.GetPreviousPropertyValue<string>("AssignedUserId");
                    if (p != null)
                        userIds.Add(p);
                }
            }
            else if (i.EntityType == typeof(DeviceProfile))
            {
                var dp = (DeviceProfile)i.Entity;

                deviceSerialNumbers.AddRange(
                    i.Database.Jobs
                        .Where(j => !j.ClosedDate.HasValue && j.Device.DeviceProfileId == dp.Id)
                        .Select(j => j.DeviceSerialNumber)
                    );
            }
            else if (i.EntityType == typeof(User))
            {
                var u = (User)i.Entity;

                deviceSerialNumbers.AddRange(
                    i.Database.Jobs
                        .Where(j => !j.ClosedDate.HasValue && j.Device.AssignedUserId == u.UserId)
                        .Select(j => j.DeviceSerialNumber)
                    );
            }

            if (deviceSerialNumbers.Count > 0 || userIds.Count > 0)
            {
                i.ExecuteAfterCommit(e =>
                {
                    BufferedUpdateStream.OnNext(Tuple.Create(deviceSerialNumbers, userIds));
                });
            }
        }
        private void ProcessRepositoryEvent(RepositoryMonitorEvent Event)
        {
            var device = (Device)Event.Entity;
            string previousDeviceDomainId = Event.GetPreviousPropertyValue<string>("DeviceDomainId");

            Event.ExecuteAfterCommit(e =>
            {
                switch (e.EventType)
                {
                    case RepositoryMonitorEventType.Added:
                        AddMember(device.DeviceDomainId + "$");
                        break;
                    case RepositoryMonitorEventType.Modified:
                        if (device.DeviceBatchId == this.DeviceBatchId)
                        {
                            if (ActiveDirectory.IsValidDomainAccountId(device.DeviceDomainId))
                                AddMember(device.DeviceDomainId + "$");

                            if (e.ModifiedProperties.Contains("DeviceDomainId"))
                            {
                                if (ActiveDirectory.IsValidDomainAccountId(previousDeviceDomainId))
                                    RemoveMember(previousDeviceDomainId + "$");
                            }
                        }
                        else
                        {
                            if (e.ModifiedProperties.Contains("DeviceDomainId"))
                            {
                                if (ActiveDirectory.IsValidDomainAccountId(previousDeviceDomainId))
                                    RemoveMember(previousDeviceDomainId + "$");
                            }
                            else
                            {
                                if (ActiveDirectory.IsValidDomainAccountId(device.DeviceDomainId))
                                    RemoveMember(device.DeviceDomainId + "$");
                            }
                        }
                        break;
                    case RepositoryMonitorEventType.Deleted:
                        if (ActiveDirectory.IsValidDomainAccountId(previousDeviceDomainId))
                            RemoveMember(previousDeviceDomainId + "$");
                        break;
                }
            });
        }