Beispiel #1
0
        public IActionResult Get([FromQuery] DocumentsSearchParametersDto searchParameters)
        {
            var result = GetDocumentsBySearchParameters <GetPagedRequestsQuery, GetPagedProtectionDocsQuery,
                                                         GetPagedContractsQuery, IPagedList <DocumentDto> >(searchParameters);

            return(result.AsOkObjectResult(this.Response));
        }
Beispiel #2
0
        public IActionResult GetExcel([FromQuery] DocumentsSearchParametersDto searchParameters)
        {
            var result = GetDocumentsBySearchParameters <GetRequestsQuery, GetProtectionDocsQuery,
                                                         GetContractsQuery, IQueryable <DocumentDto> >(searchParameters).ToList();

            var fileStream = Executor.GetCommand <GetExcelFileCommand>().Process(q => q.Execute(result, Request));

            return(File(fileStream, GetExcelFileCommand.ContentType, GetExcelFileCommand.DefaultFileName));
        }
Beispiel #3
0
        private IQueryable <SearchContractViewEntity> GetQuery(DocumentsSearchParametersDto searchParameters)
        {
            var contracts = ApplySearch(Uow.GetRepository <Contract>().AsQueryable().AsNoTracking(), searchParameters);

            var query = Uow.GetRepository <SearchContractViewEntity>().AsQueryable().AsNoTracking();

            return(from c in contracts
                   join q in query on c.Id equals q.Id
                   select q);
        }
Beispiel #4
0
        private IQueryable <SearchProtectionDocViewEntity> GetQuery(DocumentsSearchParametersDto searchParameters)
        {
            var protectionDocs = ApplySearch(Uow.GetRepository <ProtectionDoc>().AsQueryable().AsNoTracking(), searchParameters);

            var query = Uow.GetRepository <SearchProtectionDocViewEntity>().AsQueryable().AsNoTracking();

            return(from pd in protectionDocs
                   join q in query on pd.Id equals q.Id
                   select q);
        }
        public IPagedList <DocumentDto> Execute(DocumentsSearchParametersDto searchParameters, HttpRequest httpRequest)
        {
            var contracts = _executor.GetQuery <GetContractsQuery>().Process(q => q.Execute(searchParameters, httpRequest));

            return(contracts.ToPagedList(httpRequest.GetPaginationParams()));
        }
Beispiel #6
0
        private static IQueryable <Contract> ApplySearch(IQueryable <Contract> contracts, DocumentsSearchParametersDto searchParameters)
        {
            if (searchParameters.DocTypeId != null)
            {
                contracts = contracts.Where(x => x.TypeId == searchParameters.DocTypeId);
            }

            if (searchParameters.Barcode != null)
            {
                contracts = contracts.Where(x => x.Barcode == searchParameters.Barcode.Value);
            }

            if (searchParameters.ReceiveTypeId != null)
            {
                contracts = contracts.Where(x => x.ReceiveTypeId == searchParameters.ReceiveTypeId.Value);
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.NameRu))
            {
                contracts = contracts.Where(x => x.NameRu.Contains(searchParameters.NameRu));
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.NameKz))
            {
                contracts = contracts.Where(x => x.NameKz.Contains(searchParameters.NameKz));
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.NameEn))
            {
                contracts = contracts.Where(x => x.NameEn.Contains(searchParameters.NameEn));
            }

            return(contracts);
        }
Beispiel #7
0
 public IQueryable <DocumentDto> Execute(DocumentsSearchParametersDto searchParameters, HttpRequest httpRequest)
 {
     return(GetQuery(searchParameters)
            .Select(DocumentDto.FromContract)
            .Sort(httpRequest.Query));
 }
Beispiel #8
0
        /// <summary>
        /// Получает документы с учетом параметров поиска.
        /// </summary>
        /// <typeparam name="TGetRequestsQuery">Тип запроса получающего заявки.</typeparam>
        /// <typeparam name="TGetProtectionDocsQuery">Тип запроса получающего охранные документы.</typeparam>
        /// <typeparam name="TGetContractsQuery">Тип запроса получающего контракты.</typeparam>
        /// <typeparam name="TResult">Тип результирующего объекта.</typeparam>
        /// <param name="searchParameters">Параметры поиска.</param>
        /// <returns>Результирующий объект.</returns>
        private TResult GetDocumentsBySearchParameters <TGetRequestsQuery, TGetProtectionDocsQuery, TGetContractsQuery, TResult>(DocumentsSearchParametersDto searchParameters)
            where TGetRequestsQuery : BaseCommand, IBasePaymentsJournalQuery <TResult>
            where TGetProtectionDocsQuery : BaseCommand, IBasePaymentsJournalQuery <TResult>
            where TGetContractsQuery : BaseCommand, IBasePaymentsJournalQuery <TResult>
            where TResult : class
        {
            switch (searchParameters.DocumentCategory)
            {
            case DocumentCategory.Request:
                return(Executor.GetQuery <TGetRequestsQuery>().Process(q => q.Execute(searchParameters, Request)));

            case DocumentCategory.ProtectionDoc:
                return(Executor.GetQuery <TGetProtectionDocsQuery>().Process(q => q.Execute(searchParameters, Request)));

            case DocumentCategory.Contract:
                return(Executor.GetQuery <TGetContractsQuery>().Process(q => q.Execute(searchParameters, Request)));

            default:
                throw new InvalidEnumArgumentException(nameof(searchParameters.DocumentCategory),
                                                       (int)searchParameters.DocumentCategory, typeof(DocumentCategory));
            }
        }
Beispiel #9
0
        private static IQueryable <ProtectionDoc> ApplySearch(IQueryable <ProtectionDoc> protectionDocs, DocumentsSearchParametersDto searchParameters)
        {
            if (searchParameters.DocTypeId != null)
            {
                protectionDocs = protectionDocs.Where(x => x.TypeId == searchParameters.DocTypeId);
            }

            if (searchParameters.Barcode != null)
            {
                protectionDocs = protectionDocs.Where(x => x.Barcode == searchParameters.Barcode.Value);
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.NameRu))
            {
                protectionDocs = protectionDocs.Where(x => x.NameRu.Contains(searchParameters.NameRu));
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.NameKz))
            {
                protectionDocs = protectionDocs.Where(x => x.NameKz.Contains(searchParameters.NameKz));
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.NameEn))
            {
                protectionDocs = protectionDocs.Where(x => x.NameEn.Contains(searchParameters.NameEn));
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.ProtectionDocNumber))
            {
                protectionDocs = protectionDocs.Where(x => x.GosNumber == searchParameters.ProtectionDocNumber);
            }

            if (searchParameters.ProtectionDocMaintainYear != null)
            {
                protectionDocs = protectionDocs.Where(x => x.MaintainDate.Value.Year == searchParameters.ProtectionDocMaintainYear);
            }

            if (searchParameters.ProtectionDocValidDate != null)
            {
                protectionDocs = protectionDocs.Where(x => x.ValidDate.Value.Date >= searchParameters.ProtectionDocValidDate.Value.Date &&
                                                      x.ValidDate.Value.Date < searchParameters.ProtectionDocValidDate.Value.Date.AddDays(1));
            }

            if (searchParameters.ProtectionDocExtensionDate != null)
            {
                protectionDocs = protectionDocs.Where(x => x.ExtensionDate.Value.Date >= searchParameters.ProtectionDocExtensionDate.Value.Date &&
                                                      x.ExtensionDate.Value.Date < searchParameters.ProtectionDocExtensionDate.Value.Date.AddDays(1));
            }

            if (searchParameters.ProtectionDocStatusId != null)
            {
                protectionDocs = protectionDocs.Where(x => x.StatusId == searchParameters.ProtectionDocStatusId.Value);
            }

            if (searchParameters.ProtectionDocDate != null)
            {
                protectionDocs = protectionDocs.Where(x => x.GosDate.Value.Date >= searchParameters.ProtectionDocDate.Value.Date &&
                                                      x.GosDate.Value.Date < searchParameters.ProtectionDocDate.Value.Date.AddDays(1));
            }

            if (searchParameters.ProtectionDocOutgoingDate != null)
            {
                protectionDocs = protectionDocs.Where(x => x.OutgoingDate.Value.Date >= searchParameters.ProtectionDocOutgoingDate.Value.Date &&
                                                      x.OutgoingDate.Value.Date < searchParameters.ProtectionDocOutgoingDate.Value.Date.AddDays(1));
            }

            if (searchParameters.IcgsId != null)
            {
                protectionDocs = protectionDocs.Where(x => x.IcgsProtectionDocs.Any(y => y.IcgsId == searchParameters.IcgsId.Value));
            }

            if (searchParameters.SelectionAchieveTypeId != null)
            {
                protectionDocs = protectionDocs.Where(x => x.SelectionAchieveTypeId == searchParameters.SelectionAchieveTypeId.Value);
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.DeclarantName))
            {
                protectionDocs = protectionDocs.Where(x => x.ProtectionDocCustomers.Any(y => y.CustomerRole.Code == "1" && y.Customer.NameRu.Contains(searchParameters.DeclarantName)));
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.PatentOwnerName))
            {
                protectionDocs = protectionDocs.Where(x => x.ProtectionDocCustomers.Any(y => y.CustomerRole.Code == "3" && y.Customer.NameRu.Contains(searchParameters.PatentOwnerName)));
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.AuthorName))
            {
                protectionDocs = protectionDocs.Where(x => x.ProtectionDocCustomers.Any(y => y.CustomerRole.Code == "2" && y.Customer.NameRu.Contains(searchParameters.AuthorName)));
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.PatentAttorneyName))
            {
                protectionDocs = protectionDocs.Where(x => x.ProtectionDocCustomers.Any(y => y.CustomerRole.Code == "4" && y.Customer.NameRu.Contains(searchParameters.PatentAttorneyName)));
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.CorrespondenceName))
            {
                protectionDocs = protectionDocs.Where(x => x.ProtectionDocCustomers.Any(y => y.CustomerRole.Code == "12" && y.Customer.NameRu.Contains(searchParameters.CorrespondenceName)));
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.ConfidantName))
            {
                protectionDocs = protectionDocs.Where(x => x.ProtectionDocCustomers.Any(y => y.CustomerRole.Code == "6" && y.Customer.NameRu.Contains(searchParameters.ConfidantName)));
            }

            if (searchParameters.IsNotMention)
            {
                protectionDocs = protectionDocs.Where(x => x.ProtectionDocCustomers.Any(y => y.CustomerRole.Code == "2" && y.Customer.IsNotMention));
            }

            if (searchParameters.ConfidantDateFrom != null)
            {
                protectionDocs = protectionDocs.Where(x => x.ProtectionDocCustomers.Any(y => y.CustomerRole.Code == "6" &&
                                                                                        y.DateBegin.Value.Date >= searchParameters.ConfidantDateFrom.Value.Date &&
                                                                                        y.DateBegin.Value.Date < searchParameters.ConfidantDateFrom.Value.Date.AddDays(1)));
            }

            if (searchParameters.ConfidantDateTo != null)
            {
                protectionDocs = protectionDocs.Where(x => x.ProtectionDocCustomers.Any(y => y.CustomerRole.Code == "6" &&
                                                                                        y.DateEnd.Value.Date >= searchParameters.ConfidantDateTo.Value.Date &&
                                                                                        y.DateEnd.Value.Date < searchParameters.ConfidantDateTo.Value.Date.AddDays(1)));
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.AuthorCertificateNumber))
            {
                protectionDocs = protectionDocs.Where(x => x.Documents.Any(y => AuthorCertificateDocumentTypes.Contains(y.Document.Type.Code) &&
                                                                           y.Document.DocumentNum == searchParameters.AuthorCertificateNumber));
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.BulletinNumber))
            {
                protectionDocs = protectionDocs.Where(x => x.Bulletins.Any(y => y.Bulletin.Number == searchParameters.BulletinNumber));
            }

            if (searchParameters.BulletinDate != null)
            {
                protectionDocs = protectionDocs.Where(x => x.Bulletins.Any(y => y.Bulletin.PublishDate.Value.Date >= searchParameters.BulletinDate.Value.Date &&
                                                                           y.Bulletin.PublishDate.Value.Date < searchParameters.BulletinDate.Value.Date.AddDays(1)));
            }

            return(protectionDocs);
        }
Beispiel #10
0
        private static IQueryable <Request> ApplySearch(IQueryable <Request> requests, DocumentsSearchParametersDto searchParameters)
        {
            if (searchParameters.DocTypeId != null)
            {
                requests = requests.Where(x => x.ProtectionDocTypeId == searchParameters.DocTypeId);
            }

            if (searchParameters.Barcode != null)
            {
                requests = requests.Where(x => x.Barcode == searchParameters.Barcode.Value);
            }

            if (searchParameters.ReceiveTypeId != null)
            {
                requests = requests.Where(x => x.ReceiveTypeId == searchParameters.ReceiveTypeId.Value);
            }

            if (searchParameters.RequestSubTypeId != null)
            {
                requests = requests.Where(x => x.RequestTypeId == searchParameters.RequestSubTypeId.Value);
            }

            if (searchParameters.RequestTypeId != null)
            {
                requests = requests.Where(x => x.ConventionTypeId == searchParameters.RequestTypeId.Value);
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.RequestIncomingNumber))
            {
                requests = requests.Where(x => x.IncomingNumber == searchParameters.RequestIncomingNumber);
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.RequestRegNumber))
            {
                requests = requests.Where(x => x.RequestNum == searchParameters.RequestRegNumber);
            }

            if (searchParameters.RequestCreateDateFrom != null)
            {
                requests = requests.Where(x => x.DateCreate.Date >= searchParameters.RequestCreateDateFrom.Value.Date);
            }

            if (searchParameters.RequestCreateDateTo != null)
            {
                requests = requests.Where(x => x.DateCreate.Date < searchParameters.RequestCreateDateTo.Value.Date.AddDays(1));
            }

            if (searchParameters.RequestRegDateFrom != null)
            {
                requests = requests.Where(x => x.RequestDate.Value.Date >= searchParameters.RequestRegDateFrom.Value.Date);
            }

            if (searchParameters.RequestRegDateTo != null)
            {
                requests = requests.Where(x => x.RequestDate.Value.Date < searchParameters.RequestRegDateTo.Value.Date.AddDays(1));
            }

            if (searchParameters.RequestStatusId != null)
            {
                requests = requests.Where(x => x.StatusId == searchParameters.RequestStatusId.Value);
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.NameRu))
            {
                requests = requests.Where(x => x.NameRu.Contains(searchParameters.NameRu));
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.NameKz))
            {
                requests = requests.Where(x => x.NameKz.Contains(searchParameters.NameKz));
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.NameEn))
            {
                requests = requests.Where(x => x.NameEn.Contains(searchParameters.NameEn));
            }

            if (searchParameters.IcgsId != null)
            {
                requests = requests.Where(x => x.ICGSRequests.Any(y => y.IcgsId == searchParameters.IcgsId.Value));
            }

            if (searchParameters.SelectionAchieveTypeId != null)
            {
                requests = requests.Where(x => x.SelectionAchieveTypeId == searchParameters.SelectionAchieveTypeId.Value);
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.DeclarantName))
            {
                requests = requests.Where(x => x.RequestCustomers.Any(y => y.CustomerRole.Code == "1" && y.Customer.NameRu.Contains(searchParameters.DeclarantName)));
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.PatentOwnerName))
            {
                requests = requests.Where(x => x.RequestCustomers.Any(y => y.CustomerRole.Code == "3" && y.Customer.NameRu.Contains(searchParameters.PatentOwnerName)));
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.AuthorName))
            {
                requests = requests.Where(x => x.RequestCustomers.Any(y => y.CustomerRole.Code == "2" && y.Customer.NameRu.Contains(searchParameters.AuthorName)));
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.PatentAttorneyName))
            {
                requests = requests.Where(x => x.RequestCustomers.Any(y => y.CustomerRole.Code == "4" && y.Customer.NameRu.Contains(searchParameters.PatentAttorneyName)));
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.CorrespondenceName))
            {
                requests = requests.Where(x => x.RequestCustomers.Any(y => y.CustomerRole.Code == "12" && y.Customer.NameRu.Contains(searchParameters.CorrespondenceName)));
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.ConfidantName))
            {
                requests = requests.Where(x => x.RequestCustomers.Any(y => y.CustomerRole.Code == "6" && y.Customer.NameRu.Contains(searchParameters.ConfidantName)));
            }

            if (searchParameters.IsNotMention)
            {
                requests = requests.Where(x => x.RequestCustomers.Any(y => y.CustomerRole.Code == "2" && y.Customer.IsNotMention));
            }

            if (searchParameters.ConfidantDateFrom != null)
            {
                requests = requests.Where(x => x.RequestCustomers.Any(y => y.CustomerRole.Code == "6" &&
                                                                      y.DateBegin.Value.Date >= searchParameters.ConfidantDateFrom.Value.Date &&
                                                                      y.DateBegin.Value.Date < searchParameters.ConfidantDateFrom.Value.Date.AddDays(1)));
            }

            if (searchParameters.ConfidantDateTo != null)
            {
                requests = requests.Where(x => x.RequestCustomers.Any(y => y.CustomerRole.Code == "6" &&
                                                                      y.DateEnd.Value.Date >= searchParameters.ConfidantDateTo.Value.Date &&
                                                                      y.DateEnd.Value.Date < searchParameters.ConfidantDateTo.Value.Date.AddDays(1)));
            }

            if (!string.IsNullOrWhiteSpace(searchParameters.BulletinNumber))
            {
                requests = requests.Where(x => x.NumberBulletin == searchParameters.BulletinNumber);
            }

            if (searchParameters.BulletinDate != null)
            {
                requests = requests.Where(x => x.PublicDate.Value.Date >= searchParameters.BulletinDate.Value.Date &&
                                          x.PublicDate.Value.Date < searchParameters.BulletinDate.Value.Date.AddDays(1));
            }

            return(requests);
        }