private void Send(PipeMessageEnvelope message)
 {
     if (OutputDataPipe != null)
     {
         OutputDataPipe.Send(message);
     }
 }
        /// <summary>
        /// Send Worker response to Pipe.
        /// </summary>
        /// <param name="recordList"></param>
        private void Send(List <LoadFileRecord> recordList)
        {
            // In case of append, assign the dcn for the documents here
            if (m_Parameters.IsAppend)
            {
                // Assign DCN
                AssignDocumentControlNumber(recordList);
            }

            var recordCollection = new LoadFileRecordCollection
            {
                Records            = recordList,
                dataset            = m_Dataset,
                UniqueThreadString = _uniqueThreadString
            };

            OutputDataPipe.ShouldNotBe(null);
            var message = new PipeMessageEnvelope
            {
                Body = recordCollection
            };

            OutputDataPipe.Send(message);
            IncreaseProcessedDocumentsCount(recordList.Count);
        }
        /// <summary>
        /// To send the collection to the pipeline director.
        /// </summary>
        /// <param name="collection"></param>
        private void Send(DocumentCollection collection)
        {
            var message = new PipeMessageEnvelope
            {
                Body = collection
            };

            OutputDataPipe.Send(message);
        }
Пример #4
0
        /// <summary>
        /// Send Worker response to Pipe.
        /// </summary>
        private void Send(LawSyncDocumentCollection documentCollection)
        {
            var message = new PipeMessageEnvelope {
                Body = documentCollection
            };

            OutputDataPipe.Send(message);
            IncreaseProcessedDocumentsCount(documentCollection.Documents.Count);
        }
        /// <summary>
        /// Sends the specified job details.
        /// </summary>
        /// <param name="jobDetails">The job details.</param>
        private void Send(List <ProductionDocumentDetail> jobDetails)
        {
            var message = new PipeMessageEnvelope()
            {
                Body = jobDetails
            };

            OutputDataPipe.Send(message);
        }
        private void Send(DcbSlice dcbSlice)
        {
            var message = new PipeMessageEnvelope
            {
                Body = dcbSlice
            };

            OutputDataPipe.Send(message);
            IncreaseProcessedDocumentsCount(dcbSlice.NumberOfDocuments);
        }
        /// <summary>
        /// Send Worker response to Pipe.
        /// </summary>
        private void SendDataPipe()
        {
            OutputDataPipe.ShouldNotBe(null);
            var message = new PipeMessageEnvelope {
                Body = true
            };

            OutputDataPipe.Send(message);
            IncreaseProcessedDocumentsCount(_documentCount);
        }
Пример #8
0
        /// <summary>
        /// Send Worker response to Pipe.
        /// </summary>
        private void Send(ICollection jobDetails)
        {
            var message = new PipeMessageEnvelope
            {
                Body = jobDetails
            };

            OutputDataPipe.Send(message);
            IncreaseProcessedDocumentsCount(jobDetails.Count);
        }
        /// <summary>
        /// Send Worker response to Pipe.
        /// </summary>
        /// <param name="bulkTagRecord"></param>
        private void Send(BulkTagRecord bulkTagRecord)
        {
            var message = new PipeMessageEnvelope
            {
                Body = bulkTagRecord
            };

            OutputDataPipe.Send(message);
            IncreaseProcessedDocumentsCount(bulkTagRecord.Documents.Count);
        }
        /// <summary>
        /// Sends this instance.
        /// </summary>
        private void Send()
        {
            _exportDocumentCollection.Dataset = null;
            var message = new PipeMessageEnvelope()
            {
                Body = _exportDocumentCollection
            };

            OutputDataPipe.Send(message);
            IncreaseProcessedDocumentsCount(_exportDocumentCollection.Documents.Count());
        }
        private void Send(DocumentRecordCollection reviewsetRecord)
        {
            var message = new PipeMessageEnvelope
            {
                Body = reviewsetRecord
            };

            if (null != OutputDataPipe)
            {
                OutputDataPipe.Send(message);
            }
        }
        /// <summary>
        /// Send Worker response to Pipe.
        /// </summary>
        private void SendDataPipe(List <Data.NearDuplicationResultInfo> data)
        {
            OutputDataPipe.ShouldNotBe(null);
            var message = new PipeMessageEnvelope
            {
                Body = new Data.NearDuplicationResultInfoCollection {
                    ResultDocuments = data
                }
            };

            OutputDataPipe.Send(message);
        }
        private void Send(ReviewsetRecord reviewsetRecord)
        {
            var message = new PipeMessageEnvelope
            {
                Body = reviewsetRecord
            };

            if (null != OutputDataPipe)
            {
                OutputDataPipe.Send(message);
            }
        }
Пример #14
0
        private void Send(DocumentRecordCollection reviewsetRecord)
        {
            var message = new PipeMessageEnvelope
            {
                Body = reviewsetRecord
            };

            if (null != OutputDataPipe)
            {
                OutputDataPipe.Send(message);
                IncreaseProcessedDocumentsCount(reviewsetRecord.Documents.Count);
            }
        }
        /// <summary>
        /// Send Worker response to Pipe.
        /// </summary>
        private void Send(ProjectDocumentCollection data)
        {
            var message = new PipeMessageEnvelope
            {
                Body = data
            };

            if (OutputDataPipe != null)
            {
                OutputDataPipe.Send(message);
            }
            IncreaseProcessedDocumentsCount(data.Documents.Count);
        }
        /// <summary>
        /// Send Worker response to Pipe.
        /// </summary>
        /// <param name="documents"></param>
        private void Send(List <RVWDocumentBEO> documents)
        {
            OutputDataPipe.ShouldNotBe(null);
            var documentList = new LawDocumentCollection {
                Documents = documents, Dataset = _datasetDetails
            };
            var message = new PipeMessageEnvelope
            {
                Body = documentList
            };

            OutputDataPipe.Send(message);
            IncreaseProcessedDocumentsCount(documents.Count);
        }
Пример #17
0
        /// <summary>
        /// Send data to Data pipe
        /// </summary>
        /// <param name="docDetails"></param>
        private void Send(List <DocumentDetail> docDetails)
        {
            OutputDataPipe.ShouldNotBe(null);
            var documentList = new DocumentCollection()
            {
                documents = docDetails, dataset = _dataset
            };
            var message = new PipeMessageEnvelope()
            {
                Body = documentList
            };

            OutputDataPipe.Send(message);
            IncreaseProcessedDocumentsCount(docDetails.Count);
        }
Пример #18
0
        private void Send(List <DocumentDetail> docDetails)
        {
            var documentList = new DocumentCollection()
            {
                documents = docDetails, dataset = _dataset
            };
            var message = new PipeMessageEnvelope()
            {
                Body = documentList
            };

            OutputDataPipe.Send(message);
            //IncreaseProcessedDocumentsCount(docDetails.Count(DocumentDetail => DocumentDetail.docType == DocumentsetType.NativeSet));
            IncreaseProcessedDocumentsCount(docDetails.Count);
        }
Пример #19
0
        /// <summary>
        /// Send data to Data pipe
        /// </summary>
        /// <param name="docDetails"></param>
        private void Send(List <DocumentDetail> docDetails)
        {
            bool overlayIsRemoveTag = _jobParameter != null && _jobParameter != null && !_jobParameter.IsOverlayRetainTags;
            var  documentList       = new DocumentCollection()
            {
                documents = docDetails, dataset = _dataset, IsDeleteTagsForOverlay = overlayIsRemoveTag, IsIncludeNativeFile = _isIncludeNativeFile
            };
            var message = new PipeMessageEnvelope()
            {
                Body = documentList
            };

            OutputDataPipe.Send(message);
            IncreaseProcessedDocumentsCount(docDetails.Count);
        }
 /// <summary>
 /// Send Worker response to Pipe.
 /// </summary>
 /// <param name="documentCollection"></param>
 private void Send(ReviewsetSearchRecord searchRecord)
 {
     try
     {
         var message = new PipeMessageEnvelope
         {
             Body = searchRecord
         };
         OutputDataPipe.Send(message);
         IncreaseProcessedDocumentsCount(searchRecord.TotalDocumentCount);
     }
     catch (Exception ex)
     {
         Tracer.Error("SplitReviewsetStartupWorker: Send: {0}", ex);
     }
 }
Пример #21
0
 /// <summary>
 /// Send Worker response to Pipe.
 /// </summary>
 /// <param name="reviewsetRecord"></param>
 private void Send(DocumentRecordCollection reviewsetRecord)
 {
     try
     {
         var message = new PipeMessageEnvelope
         {
             Body = reviewsetRecord
         };
         OutputDataPipe.Send(message);
         IncreaseProcessedDocumentsCount(reviewsetRecord.Documents.Count);
     }
     catch (Exception ex)
     {
         Tracer.Error("SearchWorker: Send: {0}", ex);
     }
 }
Пример #22
0
        /// <summary>
        /// Send Worker response to Pipe.
        /// </summary>
        private void Send(List <DocumentResult> documentList)
        {
            var documentCollection = new PrintDocumentCollection
            {
                Documents          = documentList,
                DatasetName        = _mDatasetName,
                TotalDocumentCount = _mTotalDocumentCount
            };
            var message = new PipeMessageEnvelope
            {
                Body = documentCollection
            };

            OutputDataPipe.Send(message);
            IncreaseProcessedDocumentsCount(documentList.Count);
        }
Пример #23
0
        private void Send(ExportDocumentCollection exportDocumentCollection)
        {
            if (OutputDataPipe == null)
            {
                Tracer.Error("OutputDataPipe == null");
                return;
            }
            exportDocumentCollection.Dataset = null;
            var message = new PipeMessageEnvelope()
            {
                Body = exportDocumentCollection
            };

            OutputDataPipe.Send(message);
            IncreaseProcessedDocumentsCount(exportDocumentCollection.Documents.Count());
        }
Пример #24
0
        /// <summary>
        /// Send Worker response to Pipe.
        /// </summary>
        private void Send(ProjectDocumentRecordInfo recordInfo)
        {
            if (recordInfo == null)
            {
                return;
            }

            var message = new PipeMessageEnvelope
            {
                Body = recordInfo
            };

            if (OutputDataPipe != null)
            {
                OutputDataPipe.Send(message);
            }
        }
        /// <summary>
        /// Send Worker response to Pipe.
        /// </summary>
        private void Send(List <ProjectDocumentDetail> documents)
        {
            var documentCollection = new ProjectDocumentCollection
            {
                Documents = documents
            };
            var message = new PipeMessageEnvelope
            {
                Body = documentCollection
            };

            if (OutputDataPipe != null)
            {
                OutputDataPipe.Send(message);
            }
            IncreaseProcessedDocumentsCount(documents.Count);
        }
        /// <summary>
        /// To generate message and pass to the next worker with collection of documents in a batch
        /// </summary>
        /// <returns></returns>
        protected override bool GenerateMessage()
        {
            try
            {
                OutputDataPipe.ShouldNotBe(null);
                if (_jobParams == null)
                {
                    _jobParams = GetJobParams(BootParameters);
                }
                var documents =
                    LawBO.GetDocuments(_jobParams.LawCaseId, _selectedFields, _selectedTags, _jobParams.TagFilters);

                if (documents != null)
                {
                    var localDocumentList = new List <RVWDocumentBEO>();
                    foreach (var doc in documents)
                    {
                        doc.DocumentId = GetDocumentId();
                        //Setting the Cross Reference field with LAW DocID by default
                        doc.CrossReferenceFieldValue = doc.LawDocumentId.ToString(CultureInfo.InvariantCulture);
                        localDocumentList.Add(doc);
                        if (localDocumentList.Count % _batchSize != 0)
                        {
                            continue;
                        }
                        ProcessMessage(localDocumentList);
                        localDocumentList.Clear();
                    }

                    //Sending remaining documents for process
                    if (localDocumentList.Any())
                    {
                        ProcessMessage(localDocumentList);
                    }
                }
            }
            catch (Exception ex)
            {
                LogMessage(false, ex.ToUserString());
                ReportToDirector(ex.ToUserString());
                throw;
            }

            LogMessage(true, Constants.ParserSuccessMessage);
            return(true);
        }
Пример #27
0
        /// <summary>
        /// Send data to Data pipe
        /// </summary>
        /// <param name="docDetails"></param>
        private void Send(List <DocumentDetail> docDetails)
        {
            var documentList = new DocumentCollection
            {
                documents = docDetails,
                dataset   = _dataset,
                IsDeleteTagsForOverlay = false,
                IsIncludeNativeFile    = _isIncludeNativeFile
            };
            var message = new PipeMessageEnvelope
            {
                Body = documentList
            };

            OutputDataPipe.Send(message);
            IncreaseProcessedDocumentsCount(docDetails.Count);
        }
        private void SendData(List <ExportDocumentDetail> documentList)
        {
            var documentCollection = new ExportDocumentCollection
            {
                Documents    = documentList,
                ExportOption = _exportOption
            };
            var message = new PipeMessageEnvelope
            {
                Body = documentCollection
            };

            if (OutputDataPipe != null)
            {
                OutputDataPipe.Send(message);
            }
            IncreaseProcessedDocumentsCount(documentList.Count);
        }
        /// <summary>
        /// Sends the specified file list to next worker in the pipeline.
        /// </summary>
        /// <param name="fileList">The file list.</param>
        /// <param name="isLastBatch">if set to <c>true</c> the current batch is the last available batch[is last batch].</param>
        private void Send(IEnumerable <string> fileList, bool isLastBatch)
        {
            if (fileList == null)
            {
                return;
            }

            var message = new PipeMessageEnvelope
            {
                Body =
                    new DocumentExtractionMessageEntity {
                    FileCollection = fileList, IsLastMessageInBatch = isLastBatch
                }
            };

            OutputDataPipe.Send(message);
            IncreaseProcessedDocumentsCount(fileList.Count());
        }
Пример #30
0
 private void Send(List <ExportDocumentDetail> docDetails)
 {
     try
     {
         _exportDocumentCollection.Documents.Clear();
         _exportDocumentCollection.Documents = docDetails;
         var message = new PipeMessageEnvelope
         {
             Body = _exportDocumentCollection
         };
         OutputDataPipe.Send(message);
         IncreaseProcessedDocumentsCount(_exportDocumentCollection.Documents.Count());
     }
     catch (Exception exception)
     {
         Tracer.Error("Export Volume Worker: Unable to send message for job run id: {0} Exception details: {1}",
                      PipelineId, exception);
     }
 }