public Try <IQueryable <AnnotatedDocument> > Execute(SearchDocumentsMessage msg, string token)
        {
            Func <IQueryable <AnnotatedDocument> > query = () =>
                                                           repository.SearchToAnnotate(msg, token);

            return(Try(query));
        }
示例#2
0
        public Try <long?> Execute(SearchDocumentsMessage msg, string token)
        {
            Func <long?> query = () =>
                                 repository.SearchCountToAnnotate(
                msg.WordsToSearch,
                msg.EntityId,
                msg.DocumentTypeId,
                msg.Number,
                msg.Year,
                token);

            return(Try(query));
        }
示例#3
0
        public IQueryable <AnnotatedDocument> SearchToAnnotate(
            SearchDocumentsMessage msg,
            string token
            )
        {
            var pagePrm = new OracleParameter(
                "page", OracleDbType.Int64, System.Data.ParameterDirection.Input)
            {
                Value = msg.Page.HasValue ? msg.Page.Value : (object)null
            };

            var pageSizePrm = new OracleParameter(
                "page_size", OracleDbType.Int64, System.Data.ParameterDirection.Input);

            pageSizePrm.Value = msg.PageSize.HasValue ? msg.PageSize.Value : (object)null;

            msg.WordsToSearch = msg.WordsToSearch ?? "";
            var wordsToSearchOracleFormatForMultipleWords = Regex.Replace(msg.WordsToSearch, @"\s+", " ");

            wordsToSearchOracleFormatForMultipleWords = wordsToSearchOracleFormatForMultipleWords.Trim();
            wordsToSearchOracleFormatForMultipleWords = Regex.Replace(wordsToSearchOracleFormatForMultipleWords, @"\s+", ",");

            var wordsToSearchPrm = new OracleParameter(
                "words_to_search", OracleDbType.Varchar2, System.Data.ParameterDirection.Input)
            {
                Value = wordsToSearchOracleFormatForMultipleWords
            };

            var entity = context.Credentials
                         .Where(c => c.Token == token)
                         .Select(c => c.User.Entity);

            OracleParameter entityIdPrm;
            var             userEntity = entity.FirstOrDefault();

            if (userEntity == null)
            {
                entityIdPrm = new OracleParameter(
                    "entity", OracleDbType.Int64, System.Data.ParameterDirection.Input)
                {
                    Value = msg.EntityId.HasValue ? msg.EntityId.Value : (object)null
                };
            }
            else
            {
                entityIdPrm = new OracleParameter(
                    "entity", OracleDbType.Int64, System.Data.ParameterDirection.Input)
                {
                    Value = userEntity.Id
                };
            }

            var documentTypeIdPrm = new OracleParameter(
                "document_type", OracleDbType.Int64, System.Data.ParameterDirection.Input)
            {
                Value = msg.DocumentTypeId.HasValue ? msg.DocumentTypeId.Value : (object)null
            };

            var numberPrm = new OracleParameter(
                "doc_number", OracleDbType.Varchar2, System.Data.ParameterDirection.Input)
            {
                Value = msg.Number
            };

            var publicationYearPrm = new OracleParameter(
                "pub_year", OracleDbType.Int64, System.Data.ParameterDirection.Input)
            {
                Value = msg.Year.HasValue ? msg.Year.Value : (object)null
            };

            var orderByPrm = new OracleParameter(
                "order_by", OracleDbType.Varchar2, System.Data.ParameterDirection.Input)
            {
                Value = msg.OrderBy
            };

            var descendPrm = new OracleParameter(
                "descend", OracleDbType.Boolean, System.Data.ParameterDirection.Input)
            {
                Value = msg.Descend
            };

            return(context.Documents
                   .Include(d => d.File)
                   .FromSql("SELECT * FROM TABLE(search_dt(:page, :page_size, :words_to_search, :entity, :document_type, :doc_number, :pub_year, :order_by, :descend))",
                            pagePrm,
                            pageSizePrm,
                            wordsToSearchPrm,
                            entityIdPrm,
                            documentTypeIdPrm,
                            numberPrm,
                            publicationYearPrm,
                            orderByPrm,
                            descendPrm
                            ).Select(d =>
                                     new AnnotatedDocument {
                Id = d.Id,
                DocumentTypeId = d.DocumentTypeId,
                EntityId = d.EntityId,
                Number = d.Number,
                PublicationDate = d.PublicationDate,
                PublicationYear = d.PublicationYear,
                IsAnnotated = context.Annotations.Where(a => a.To.Id == d.Id).Any(),
                FileId = d.File.DocumentId,
                FileName = d.File.Name,
                Issue = d.File.Issue
            }
                                     ));
        }