예제 #1
0
        private async Task SetGroupStatus(string status, bool trainingStatus)
        {
            string statusDetail = trainingStatus ? Constant.Group.COMPLETE : Constant.Group.INCOMPLETE;

            using (IObjectManager objectManager = Helper.GetServicesManager().CreateProxy <IObjectManager>(ExecutionIdentity.CurrentUser))
            {
                RelativityObjectRef relativityObject = new RelativityObjectRef {
                    ArtifactID = ActiveArtifact.ArtifactID
                };
                FieldRefValuePair fieldValuePair = new FieldRefValuePair
                {
                    Field = new FieldRef()
                    {
                        Guid = Constant.Guids.Field.FaceRecognitionGroup.TRAINING_STATUS
                    },
                    Value = status + statusDetail
                };

                UpdateRequest updateRequest = new UpdateRequest
                {
                    Object      = relativityObject,
                    FieldValues = new List <FieldRefValuePair> {
                        fieldValuePair
                    }
                };

                await objectManager.UpdateAsync(Helper.GetActiveCaseID(), updateRequest);
            }
        }
예제 #2
0
        private async Task SetPersonStatus(int workspaceArtifactId, int personArtifactId, string status)
        {
            using (IObjectManager objectManager = Helper.GetServicesManager().CreateProxy <IObjectManager>(ExecutionIdentity.CurrentUser))
            {
                //Set Status field for current Person
                RelativityObjectRef relativityObject = new RelativityObjectRef {
                    ArtifactID = personArtifactId
                };
                FieldRefValuePair fieldValuePair = new FieldRefValuePair
                {
                    Field = new FieldRef()
                    {
                        Guid = Constant.Guids.Field.FaceRecognitionPerson.STATUS
                    },
                    Value = status
                };

                UpdateRequest updateRequest = new UpdateRequest
                {
                    Object      = relativityObject,
                    FieldValues = new List <FieldRefValuePair> {
                        fieldValuePair
                    }
                };

                UpdateResult updateResult = await objectManager.UpdateAsync(workspaceArtifactId, updateRequest);
            }
        }
예제 #3
0
        private async Task SetGroupId(string groupId = null)
        {
            using (IObjectManager objectManager = Helper.GetServicesManager().CreateProxy <IObjectManager>(ExecutionIdentity.CurrentUser))
            {
                RelativityObjectRef relativityObject = new RelativityObjectRef {
                    ArtifactID = ActiveArtifact.ArtifactID
                };
                FieldRefValuePair fieldValuePair = new FieldRefValuePair
                {
                    Field = new FieldRef()
                    {
                        Guid = Constant.Guids.Field.FaceRecognitionGroup.GROUP_ID
                    },
                    Value = groupId
                };

                UpdateRequest updateRequest = new UpdateRequest
                {
                    Object      = relativityObject,
                    FieldValues = new List <FieldRefValuePair> {
                        fieldValuePair
                    }
                };

                await objectManager.UpdateAsync(Helper.GetActiveCaseID(), updateRequest);
            }
        }
예제 #4
0
 private async Task SetStatus(string status)
 {
     try
     {
         using (IObjectManager manager = this.Helper.GetServicesManager().CreateProxy <IObjectManager>(Relativity.API.ExecutionIdentity.System))
         {
             var toUpdate = new RelativityObjectRef {
                 ArtifactID = ActiveArtifact.ArtifactID
             };
             var fieldValuePair = new FieldRefValuePair()
             {
                 Field = new FieldRef()
                 {
                     Guid = ApplicationConstants.INDEX_JOB_STATUS
                 }, Value = status
             };
             var updateRequest = new UpdateRequest {
                 Object = toUpdate, FieldValues = new FieldRefValuePair[] { fieldValuePair }
             };
             await manager.UpdateAsync(this.Helper.GetActiveCaseID(), updateRequest);
         }
     }
     catch (Exception ex)
     {
         LogError(ex);
     }
 }
        private async Task SetImageStatus(int workspaceArtifactId, int imageArtifactId, string status)
        {
            using (IObjectManager objectManager = CreateObjectManager())
            {
                //Set Status field for current Image
                RelativityObjectRef relativityObject = new RelativityObjectRef {
                    ArtifactID = imageArtifactId
                };
                FieldRefValuePair fieldValuePair = new FieldRefValuePair
                {
                    Field = new FieldRef()
                    {
                        Guid = Constant.Guids.Field.FaceRecognitionImage.STATUS
                    },
                    Value = status
                };

                UpdateRequest updateRequest = new UpdateRequest
                {
                    Object      = relativityObject,
                    FieldValues = new List <FieldRefValuePair> {
                        fieldValuePair
                    }
                };

                UpdateResult updateResult = await objectManager.UpdateAsync(workspaceArtifactId, updateRequest);
            }
        }
예제 #6
0
 private async Task WriteValuesToDocumentObject(IndexJob indexJob, VideoIndexResult videoIndexResult)
 {
     try
     {
         using (IObjectManager manager = this.Helper.GetServicesManager().CreateProxy <IObjectManager>(Relativity.API.ExecutionIdentity.System))
         {
             var toUpdate = new RelativityObjectRef {
                 ArtifactID = indexJob.DocumentArtifactID
             };
             var fieldValuePair = new FieldValue("Kramerica Video Transcript", videoIndexResult.Transcript);
             var updateRequest  = new UpdateRequest
             {
                 Object      = toUpdate,
                 FieldValues = new List <FieldRefValuePair> {
                     fieldValuePair
                 }
             };
             await manager.UpdateAsync(indexJob.WorkspaceArtifactID, updateRequest);
         }
     }
     catch (Exception ex)
     {
         LogError(ex);
     }
 }
예제 #7
0
 private async Task UpdateStatus(IndexJob indexJob, string status)
 {
     try
     {
         using (IObjectManager manager = this.Helper.GetServicesManager().CreateProxy <IObjectManager>(Relativity.API.ExecutionIdentity.System))
         {
             var toUpdate = new RelativityObjectRef {
                 ArtifactID = indexJob.JobArtifactID
             };
             var fieldValuePair = new FieldValue("Status", status);
             var updateRequest  = new UpdateRequest
             {
                 Object      = toUpdate,
                 FieldValues = new List <FieldRefValuePair> {
                     fieldValuePair
                 }
             };
             await manager.UpdateAsync(indexJob.WorkspaceArtifactID, updateRequest);
         }
     }
     catch (Exception ex)
     {
         LogError(ex);
     }
 }
예제 #8
0
 private async Task WriteValuesToIndexJob(IndexJob indexJob, VideoIndexResult videoIndexResult)
 {
     try
     {
         using (IObjectManager manager = this.Helper.GetServicesManager().CreateProxy <IObjectManager>(Relativity.API.ExecutionIdentity.System))
         {
             var toUpdate = new RelativityObjectRef {
                 ArtifactID = indexJob.JobArtifactID
             };
             var fields = new FieldValue[]
             {
                 new FieldValue("VideoID", videoIndexResult.VideoID),
                 new FieldValue("Video File Name", videoIndexResult.VideoName),
                 new FieldValue("DocumentControlNumber", videoIndexResult.ControlNumber)
             };
             var updateRequest = new UpdateRequest {
                 Object = toUpdate, FieldValues = fields
             };
             await manager.UpdateAsync(indexJob.WorkspaceArtifactID, updateRequest);
         }
     }
     catch (Exception ex)
     {
         LogError(ex);
     }
 }
예제 #9
0
        private void TextStreamer(object obj)
        {
            foreach (RelativityObjectSlim ros in _streamQueue.GetConsumingEnumerable())
            {
                if (_cancellationToken.IsCancellationRequested)
                {
                    break;
                }

                RelativityObjectRef documentObjectRef = new RelativityObjectRef {
                    ArtifactID = ros.ArtifactID
                };

                try
                {
                    foreach (int index in _longTextIds)
                    {
                        object longText = ros.Values[index];
                        if (longText != null && longText.ToString().Equals(_SHIBBOLETH))
                        {
                            IKeplerStream keplerStream = _objectManager
                                                         .StreamLongTextAsync(_workspaceId, documentObjectRef, _queryRequest.Fields.ElementAt(index)).Result;
                            Stream realStream = keplerStream.GetStreamAsync().Result;
                            ros.Values[index] = realStream;
                        }
                    }
                }
                catch (Exception exception)
                {
                    // Close any streams we already opened in this ROS
                    CloseOpenStreamsInRos(ros);
                    // Send error to handler and cancel
                    SendErrorAndCancel("StreamLongTextAsync failed", exception);
                    // Skip rest of loop
                    break;
                }

                try
                {
                    _openStreamQueue.Add(ros, _cancellationToken);
                }
                catch (OperationCanceledException) { }
            }

            // Close all open streams in the Open Stream Queue if we are canceling

            if (_cancellationToken.IsCancellationRequested)
            {
                // close open streams left in open stream queue
                _openStreamQueue.CompleteAdding();
                foreach (RelativityObjectSlim rosToClose in _openStreamQueue.GetConsumingEnumerable())
                {
                    CloseOpenStreamsInRos(rosToClose);
                }
            }
        }
예제 #10
0
        /// <summary>
        /// THIS is the method that needs to be what each
        /// thread executes--streams the text to a file.
        /// </summary>
        public static void StreamToFile()
        {
            // buffer size for file IO
            const int BUFFER_SIZE = 5000;

            while (!_writeJobs.IsCompleted)
            {
                WriteJob op;
                bool     success = _writeJobs.TryTake(out op);
                if (!success)
                {
                    Thread.Sleep(100);
                    continue;
                }

                // stream

                // create ref to object
                var relativityObj = new RelativityObjectRef
                {
                    ArtifactID = op.DocumentId
                };

                // create ref to field
                var longTextFieldRef = new FieldRef
                {
                    ArtifactID = op.LongTextFieldId
                };

                // instantiate object manager service
                using (IObjectManager objMgr = ServiceFactory.CreateProxy <IObjectManager>())
                    using (IKeplerStream ks = objMgr.StreamLongTextAsync(
                               op.WorkspaceId, relativityObj, longTextFieldRef).Result)
                        using (Stream s = ks.GetStreamAsync().Result)
                            using (var reader = new StreamReader(s))
                                using (var writer = new StreamWriter(op.Path, append: false))
                                {
                                    char[] buffer = new char[BUFFER_SIZE];

                                    int copied;
                                    do
                                    {
                                        copied = reader.Read(buffer, 0, BUFFER_SIZE);
                                        writer.Write(
                                            copied == BUFFER_SIZE
                            ? buffer
                            : buffer.Take(copied).ToArray());
                                        writer.Flush();
                                    } while (copied > 0);
                                }
            }
        }
예제 #11
0
        public async Task UpdateRelativity(IServicesMgr serviceManager, int workspaceId, int modelArtifactId)
        {
            using (IObjectManager objectManager = serviceManager.CreateProxy <IObjectManager>(ExecutionIdentity.System))
            {
                RelativityObjectRef relativityObject = new RelativityObjectRef {
                    ArtifactID = modelArtifactId
                };
                List <FieldRefValuePair> fieldValues = new List <FieldRefValuePair>
                {
                    new FieldRefValuePair
                    {
                        Field = new FieldRef()
                        {
                            Guid = Guids.Model.MODEL_GUID_FIELD
                        },
                        Value = ModelGuid.ToString()
                    },
                    new FieldRefValuePair
                    {
                        Field = new FieldRef()
                        {
                            Guid = Guids.Model.SAS_URL_FIELD
                        },
                        Value = SasUrl
                    }
                };

                UpdateRequest updateRequest = new UpdateRequest
                {
                    Object      = relativityObject,
                    FieldValues = fieldValues
                };

                UpdateResult result = await objectManager.UpdateAsync(workspaceId, updateRequest);
            }
        }
        private async Task <bool> UpdateStatus()
        {
            bool success = false;

            try
            {
                kCura.EventHandler.Field myStatusField = this.ActiveArtifact.Fields[ApplicationConstants.INDEX_JOB_STATUS.ToString()];
                if (myStatusField.Value.Value == null)
                {
                    using (IObjectManager manager = this.Helper.GetServicesManager().CreateProxy <IObjectManager>(Relativity.API.ExecutionIdentity.CurrentUser))
                    {
                        var toUpdate = new RelativityObjectRef {
                            ArtifactID = ActiveArtifact.ArtifactID
                        };
                        var fieldValuePair = new FieldRefValuePair()
                        {
                            Field = new FieldRef()
                            {
                                Guid = ApplicationConstants.INDEX_JOB_STATUS
                            }, Value = "Created"
                        };
                        var updateRequest = new UpdateRequest {
                            Object = toUpdate, FieldValues = new FieldRefValuePair[] { fieldValuePair }
                        };
                        await manager.UpdateAsync(this.Helper.GetActiveCaseID(), updateRequest);
                    }
                }
                success = true;
            }
            catch (Exception ex)
            {
                LogError(ex);
                success = false;
            }
            return(success);
        }
예제 #13
0
        public async Task UpdateRelativity(IServicesMgr serviceManager, int workspaceId, int invoiceArtifactId)
        {
            using (IObjectManager objectManager = serviceManager.CreateProxy <IObjectManager>(ExecutionIdentity.System))
            {
                RelativityObjectRef relativityObject = new RelativityObjectRef {
                    ArtifactID = invoiceArtifactId
                };
                List <FieldRefValuePair> fieldValues = new List <FieldRefValuePair>
                {
                    new FieldRefValuePair
                    {
                        Field = new FieldRef()
                        {
                            Guid = Guids.Invoice.TO_FIELD
                        },
                        Value = To
                    },
                    new FieldRefValuePair
                    {
                        Field = new FieldRef()
                        {
                            Guid = Guids.Invoice.FROM_FIELD
                        },
                        Value = From
                    },
                    new FieldRefValuePair
                    {
                        Field = new FieldRef()
                        {
                            Guid = Guids.Invoice.DATE_OF_ISSUE_FIELD
                        },
                        Value = DateOfIssue
                    },
                    new FieldRefValuePair
                    {
                        Field = new FieldRef()
                        {
                            Guid = Guids.Invoice.DUE_DATE_FIELD
                        },
                        Value = DueDate
                    },
                    new FieldRefValuePair
                    {
                        Field = new FieldRef()
                        {
                            Guid = Guids.Invoice.TOTAL_AMOUNT_DUE_FIELD
                        },
                        Value = TotalAmountDue
                    }
                };

                UpdateRequest updateRequest = new UpdateRequest
                {
                    Object      = relativityObject,
                    FieldValues = fieldValues
                };

                UpdateResult result = await objectManager.UpdateAsync(workspaceId, updateRequest);

                if (invoiceArtifactId > 0)
                {
                    foreach (InvoiceLineItem lineItem in LineItems)
                    {
                        await lineItem.CreateRelativity(serviceManager, workspaceId, invoiceArtifactId);
                    }
                }
            }
        }
예제 #14
0
        /*
         * Custom method to translate document using Azure Translator
         */
        private async Task <int> TranslateDocument(int workspaceId, int documentArtifactId, string sourceField, string destinationField, string logField, string azureServiceRegion, string azureSubscriptionKey, string azureTranslatorEndpoint, string translateFrom, string translateTo)
        {
            /*
             * Custom local function to split string into chunks of defined size with delimiter priority
             */
            List <string> SplitMulti(string str, char[] delimiters, int minChunkThreshold, int maxChunkThreshold, int smallChunkThreshold)
            {
                List <string> chunks = new List <string>()
                {
                    str
                };
                List <string> subChunks;

                foreach (char delimiter in delimiters)
                {
                    for (int i = 0; i < chunks.Count; i++)
                    {
                        // Check if chunks are all below threshold otherwise split by space
                        if (chunks[i].Length > maxChunkThreshold)
                        {
                            subChunks = SplitSized(chunks[i], delimiter, minChunkThreshold, maxChunkThreshold, smallChunkThreshold);
                            chunks.RemoveAt(i);
                            chunks.InsertRange(i, subChunks);
                        }
                    }
                }

                return(chunks);
            }

            /*
             * Custom local function to split string into chunks of defined size
             */
            List <string> SplitSized(string str, char delimiter, int minChunkThreshold, int maxChunkThreshold, int smallChunkThreshold)
            {
                string[]      split  = str.Split(delimiter);
                List <string> chunks = new List <string>();

                string hlp = split[0];

                for (int i = 1; i < split.Length; i++)
                {
                    // Rearange split text into bigger chunks
                    if (((hlp.Length + split[i].Length) < minChunkThreshold || split[i].Length < smallChunkThreshold) && ((hlp.Length + split[i].Length) < maxChunkThreshold))
                    {
                        hlp = hlp + delimiter + split[i];
                    }
                    else
                    {
                        chunks.Add(hlp + delimiter);
                        hlp = split[i];
                    }
                }
                chunks.Add(hlp);

                return(chunks);
            }

            // Get logger
            Relativity.API.IAPILog _logger = this.Helper.GetLoggerFactory().GetLogger().ForContext <MassOperationHandler>();

            // Get Relativity Object Manager API
            IObjectManager objectManager = this.Helper.GetServicesManager().CreateProxy <IObjectManager>(ExecutionIdentity.CurrentUser);

            // Get document text
            Stream streamToTranslate;

            try
            {
                // Construct objects and retreive document content
                RelativityObjectRef relativityObject = new RelativityObjectRef
                {
                    ArtifactID = documentArtifactId
                };
                FieldRef relativityField = new FieldRef
                {
                    Name = sourceField
                };
                IKeplerStream keplerStream = await objectManager.StreamLongTextAsync(workspaceId, relativityObject, relativityField);

                streamToTranslate = await keplerStream.GetStreamAsync();
            }
            catch (Exception e)
            {
                _logger.LogError(e, "Azure Translator, document for translation retrieval error (ArtifactID: {id})", documentArtifactId.ToString());
                return(documentArtifactId);
            }

            // Copy stream to text as that is used for further on
            string textToTranslate = new StreamReader(streamToTranslate).ReadToEnd();

            // Log original document
            _logger.LogDebug("Azure Translator, original document (ArtifactID: {id}, length: {length})", documentArtifactId.ToString(), textToTranslate.Length.ToString());

            // Split document text to chunks as Azure Translator request is limited by 10K characters
            List <string> partsToTranslate = SplitMulti(textToTranslate, new char[] { '.', ' ' }, 9000, 9900, 20);

            _logger.LogDebug("Azure Translator, document split into {n} parts (ArtifactID: {id})", partsToTranslate.Count.ToString(), documentArtifactId.ToString());

            // Force TLS 1.2 or higher as Azure requires it
            ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls12 & ~(SecurityProtocolType.Ssl3 | SecurityProtocolType.Tls | SecurityProtocolType.Tls11);

            // URL encode request paramenters
            translateFrom = WebUtility.HtmlEncode(translateFrom.ToLower());
            translateTo   = WebUtility.HtmlEncode(translateTo.ToLower());

            // Do Azure Translator call for every text part
            List <string> partsTranslated = new List <string>();

            for (int i = 0; i < partsToTranslate.Count; i++)
            {
                // Build translation request
                HttpRequestMessage request = new HttpRequestMessage();
                request.Method     = HttpMethod.Post;
                request.RequestUri = new Uri(azureTranslatorEndpoint + "translate?api-version=3.0&to=" + translateTo + (translateFrom == "auto" ? "" : "&from=" + translateFrom) + "&includeAlignment=true");  // https://docs.microsoft.com/azure/cognitive-services/translator/reference/v3-0-translate
                request.Content    = new StringContent(JsonConvert.SerializeObject(new object[] { new { Text = partsToTranslate[i] } }), Encoding.UTF8, "application/json");
                request.Headers.Add("Ocp-Apim-Subscription-Key", azureSubscriptionKey);
                request.Headers.Add("Ocp-Apim-Subscription-Region", azureServiceRegion);

                // Send the request
                HttpClient          client   = new HttpClient();
                HttpResponseMessage response = await client.SendAsync(request).ConfigureAwait(false);

                // Check the response
                if (response.StatusCode != HttpStatusCode.OK)
                {
                    _logger.LogError("Azure Translator, HTTP reposnse error (ArtifactID: {id}, status: {status})", documentArtifactId.ToString(), response.StatusCode.ToString());
                    return(documentArtifactId);
                }

                // Read the response
                string partTranslated = await response.Content.ReadAsStringAsync();

                _logger.LogDebug("Azure Translator, translation result JSON check (ArtifactID: {id}, length: {length})", documentArtifactId.ToString(), partTranslated.Length.ToString());
                client.Dispose();

                // Parse JSON
                TranslationResult[] translationResults = JsonConvert.DeserializeObject <TranslationResult[]>(partTranslated);

                // Check the translation result
                if (translationResults.Length > 1 || translationResults[0].Translations.Length > 1)
                {
                    _logger.LogError("Azure Translator, unexpected document translation results (ArtifactID: {id})", documentArtifactId.ToString());
                    return(documentArtifactId);
                }
                if (translationResults.Length == 0 || translationResults[0].Translations.Length == 0)
                {
                    _logger.LogError("Azure Translator, empty document translation results (ArtifactID: {id})", documentArtifactId.ToString());
                    return(documentArtifactId);
                }

                // Log the translation result
                _logger.LogDebug("Azure Translator, translation check (ArtifactID: {id}, part: {part}, length: {length})", documentArtifactId.ToString(), i.ToString(), translationResults[0].Translations[0].Text.Length.ToString());
                // Get the translation result
                partsTranslated.Add(translationResults[0].Translations[0].Text);
            }

            // Construct translated text
            string       textTranslated   = string.Join(string.Empty, partsTranslated);
            Stream       streamTranslated = new MemoryStream();
            StreamWriter streamWriter     = new StreamWriter(streamTranslated);

            streamWriter.Write(textTranslated);
            streamWriter.Flush();
            streamTranslated.Position = 0;

            // Log translated document
            _logger.LogDebug("Azure Translator, translated document (ArtifactID: {id}, length: {length})", documentArtifactId.ToString(), textTranslated.Length.ToString());

            // Update document translated text
            try
            {
                // Construct objects and do document update
                RelativityObjectRef relativityObject = new RelativityObjectRef
                {
                    ArtifactID = documentArtifactId
                };
                FieldRef relativityField = new FieldRef
                {
                    Name = destinationField
                };
                UpdateLongTextFromStreamRequest updateRequest = new UpdateLongTextFromStreamRequest
                {
                    Object = relativityObject,
                    Field  = relativityField
                };
                KeplerStream keplerStream = new KeplerStream(streamTranslated);
                await objectManager.UpdateLongTextFromStreamAsync(workspaceId, updateRequest, keplerStream);
            }
            catch (Exception e)
            {
                _logger.LogError(e, "Azure Translator, document for translation update error (ArtifactID: {id})", documentArtifactId.ToString());
                return(documentArtifactId);
            }

            // Update document translation log
            try
            {
                Stream streamCurrentLog;
                // Construct objects and get current translation log
                RelativityObjectRef relativityObject = new RelativityObjectRef
                {
                    ArtifactID = documentArtifactId
                };
                FieldRef relativityField = new FieldRef
                {
                    Name = logField
                };
                IKeplerStream keplerStream = await objectManager.StreamLongTextAsync(workspaceId, relativityObject, relativityField);

                streamCurrentLog = await keplerStream.GetStreamAsync();

                // Add new translation log
                Stream       streamUpdatedLog = new MemoryStream();
                StreamWriter streamLogWriter  = new StreamWriter(streamUpdatedLog);
                streamLogWriter.Write(new StreamReader(streamCurrentLog).ReadToEnd());
                streamLogWriter.Write("Azure Translator;" + this.Helper.GetAuthenticationManager().UserInfo.EmailAddress + ";" + DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss") + ";" + translateFrom + ";" + translateTo + ";" + textToTranslate.Length.ToString() + ";" + textTranslated.Length.ToString() + "\n");
                streamLogWriter.Flush();
                streamUpdatedLog.Position = 0;

                // Write updated translation log
                UpdateLongTextFromStreamRequest updateRequest = new UpdateLongTextFromStreamRequest
                {
                    Object = relativityObject,
                    Field  = relativityField
                };
                keplerStream = new KeplerStream(streamUpdatedLog);
                await objectManager.UpdateLongTextFromStreamAsync(workspaceId, updateRequest, keplerStream);
            }
            catch (Exception e)
            {
                _logger.LogError(e, "Azure Translator, translation log update error (ArtifactID: {id})", documentArtifactId.ToString());
                return(documentArtifactId);
            }

            // Return 0 as all went without error
            return(0);
        }