public static IQueryable <IAccessRightsRule> GetAccessRightsRulesByDocumentKind(IDocumentKind documentKind)
        {
            var rules = AccessRightsRules.GetAll();

            return(AccessRightsRules.GetAll(r => r.Status == Docflow.AccessRightsRule.Status.Active)
                   .Where(r => r.DocumentKinds.Any(k => k.DocumentKind.Id == documentKind.Id)));
        }
Esempio n. 2
0
        /// <summary>
        /// Асинхронная выдача прав на документы от правила.
        /// </summary>
        /// <param name="args">Параметры вызова асинхронного обработчика.</param>
        public virtual void GrantAccessRightsToDocumentsByRule(Sungero.Docflow.Server.AsyncHandlerInvokeArgs.GrantAccessRightsToDocumentsByRuleInvokeArgs args)
        {
            int ruleId = args.RuleId;

            Logger.DebugFormat("TryGrantRightsByRule: start create documents queue for rule {0}", ruleId);

            var rule = AccessRightsRules.GetAll(r => r.Id == ruleId).FirstOrDefault();

            if (rule == null)
            {
                return;
            }

            foreach (var ruleDocument in GetDocumentsByRule(rule))
            {
                PublicFunctions.Module.CreateGrantAccessRightsToDocumentAsyncHandler(ruleDocument, rule.Id, true);
                Logger.DebugFormat("TryGrantRightsByRule: create document queue for document {0}, rule {1}", ruleDocument, ruleId);
            }

            Logger.DebugFormat("TryGrantRightsByRule: success create documents queue for rule {0}", ruleId);
        }
Esempio n. 3
0
        /// <summary>
        /// Автоматическая выдача прав на документы.
        /// </summary>
        public virtual void GrantAccessRightsToDocuments()
        {
            // Отключение ФП для проверки тестов.
            if (PublicFunctions.Module.GetGrantRightMode() != Constants.Module.GrantRightsModeByJob)
            {
                return;
            }

            var startDate     = Calendar.Now;
            var lastStartDate = PublicFunctions.Module.GetLastAgentRunDate(Constants.Module.LastAccessRightsUpdateDate);

            var allRules = AccessRightsRules.GetAll(s => s.Status == Docflow.AccessRightsRule.Status.Active).ToList();

            if (!allRules.Any())
            {
                PublicFunctions.Module.UpdateLastAgentRunDate(Constants.Module.LastAccessRightsUpdateDate, startDate);
                return;
            }

            var hasRuleWithLeadingDocuments = allRules.Any(s => s.GrantRightsOnLeadingDocument == true);

            // Измененные документы.
            var queue = new List <Structures.DocumentGrantRightsQueueItem.ProxyQueueItem>();
            var changedDocumentIds = OfficialDocuments.GetAll(d => d.Modified >= lastStartDate && d.Modified <= startDate).Select(d => d.Id);

            foreach (var documentId in changedDocumentIds)
            {
                var document = OfficialDocuments.GetAll(d => d.Id == documentId).FirstOrDefault();
                if (document == null)
                {
                    continue;
                }

                var documentRules = GetAvailableRules(document, allRules);
                foreach (var documentRule in documentRules)
                {
                    queue.Add(CreateAccessRightsQueueItem(documentId, documentRule, Docflow.DocumentGrantRightsQueueItem.ChangedEntityType.Document));
                }

                // Проверить наличие правил для ведущих документов, если есть хотя бы одно такое правило.
                if (hasRuleWithLeadingDocuments)
                {
                    var leadingDocumentIds = GetLeadingDocuments(document);
                    foreach (var leadingDocumentId in leadingDocumentIds)
                    {
                        var leadingDocument   = OfficialDocuments.GetAll(d => d.Id == leadingDocumentId).FirstOrDefault();
                        var leadDocumentRules = GetAvailableRules(leadingDocument, allRules);
                        foreach (var leadDocumentRule in leadDocumentRules)
                        {
                            queue.Add(CreateAccessRightsQueueItem(leadingDocument.Id, leadDocumentRule, Docflow.DocumentGrantRightsQueueItem.ChangedEntityType.Document));
                        }

                        leadingDocument = leadingDocument.LeadingDocument;
                    }
                }
            }

            // Измененные настройки.
            var changedRules = allRules.Where(s =>
                                              s.Modified >= lastStartDate &&
                                              s.Modified <= startDate &&
                                              s.GrantRightsOnExistingDocuments == true);

            foreach (var changedRule in changedRules)
            {
                foreach (var ruleDocument in GetDocumentsByRule(changedRule))
                {
                    queue.Add(CreateAccessRightsQueueItem(ruleDocument, changedRule, Docflow.DocumentGrantRightsQueueItem.ChangedEntityType.Rule));
                }
            }

            var table = DocumentGrantRightsQueueItems.Info.DBTableName;
            var ids   = Sungero.Domain.IdentifierGenerator.GenerateIdentifiers(table, queue.Count).ToList();

            for (int i = 0; i < queue.Count; i++)
            {
                queue[i].Id = ids[i];
            }
            Docflow.PublicFunctions.Module.WriteStructuresToTable(table, queue);
            Logger.DebugFormat("GrantAccessRightsToDocuments: Added to queue {0} documents.", queue.Count);

            // Обновить дату запуска агента в базе.
            PublicFunctions.Module.UpdateLastAgentRunDate(Constants.Module.LastAccessRightsUpdateDate, startDate);

            // Выдать права на документы.
            var step    = 5;
            var error   = 0;
            var isEmpty = false;

            for (int i = 0; i < 10000; i = i + step)
            {
                // Если элементов больше нет - заканчиваем.
                if (isEmpty)
                {
                    break;
                }

                var result = Transactions.Execute(
                    () =>
                {
                    Logger.DebugFormat("GrantAccessRightsToDocuments: Start process queue from {0}.", i);

                    // Т.к. в конце транзакции элементы удаляются, в Take берем просто N новых элементов.
                    var queueItemPart = DocumentGrantRightsQueueItems.GetAll().Skip(error).Take(step).ToList();
                    if (!queueItemPart.Any())
                    {
                        // Завершаем транзакцию, если больше нечего обрабатывать.
                        isEmpty = true;
                        return;
                    }

                    var accessRightsGranted = queueItemPart
                                              .Where(q => this.GrantRightsToDocumentByRules(q, allRules))
                                              .ToList();
                    if (accessRightsGranted.Any())
                    {
                        Functions.Module.FastDeleteQueueItems(accessRightsGranted.Select(a => a.Id).ToList());
                    }
                    error += queueItemPart.Count - accessRightsGranted.Count;
                });
                if (!result)
                {
                    error += step;
                }
            }
        }