private static async Task DeleteWorkspaceAsync() { Console2.WriteStartHeader("Delete Workspace"); Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); Console.WriteLine("Would you like to delete the created workspace (type 'y' or 'n'):"); string response = Console.ReadLine(); if (response == null || response.ToLower().Equals("y")) { WorkspaceHelper workspaceHelper = new WorkspaceHelper(_connectionManager.RsapiClient); // Delete workspace await workspaceHelper.DeleteWorkspaceAsync(_workspaceArtifactId); } stopwatch.Stop(); DisplayTimeElapsed(stopwatch.Elapsed); }
private static void InitializeGlobalSettings() { Console2.WriteTapiStartHeader("Initialize GlobalSettings"); // A meaningful application name is encoded within monitoring data. GlobalSettings.Instance.ApplicationName = "sample-app"; // Configure for a console-based application. GlobalSettings.Instance.CommandLineModeEnabled = true; Console2.WriteDebugLine("Configured console settings."); // This will automatically write real-time entries into the transfer log. GlobalSettings.Instance.StatisticsLogEnabled = true; GlobalSettings.Instance.StatisticsLogIntervalSeconds = .5; Console2.WriteDebugLine("Configured statistics settings."); // Limit the max target rate and throw exceptions when invalid paths are specified. GlobalSettings.Instance.MaxAllowedTargetDataRateMbps = 10; Console2.WriteDebugLine("Configured miscellaneous settings."); Console2.WriteTapiEndHeader(); }
public static async Task <int> CreateProcessingSetAsync(HttpClient httpClient, int processingProfileArtifactId, int workspaceId) { try { string url = "Relativity.REST/api/Relativity.Processing.Services.IProcessingModule/Processing Set Manager/SaveAsync"; ProcessingSetSaveRequest processingSetSaveRequest = new ProcessingSetSaveRequest { ProcessingSet = new Processingset { Name = Constants.Processing.Set.NAME, Profile = new Profile { ArtifactID = processingProfileArtifactId } }, workspaceArtifactId = workspaceId }; string request = JsonConvert.SerializeObject(processingSetSaveRequest); Console2.WriteDisplayStartLine($"Creating Processing Set [Name: {Constants.Processing.Set.NAME}]"); HttpResponseMessage response = RESTConnectionManager.MakePost(httpClient, url, request); string result = await response.Content.ReadAsStringAsync(); bool success = HttpStatusCode.OK == response.StatusCode; if (!success) { throw new Exception("Failed to Create Processing Set"); } int processingSetArtifactId = Int32.Parse(result); Console2.WriteDebugLine($"Processing Set ArtifactId: {processingSetArtifactId}"); Console2.WriteDisplayEndLine("Created Processing Set!"); return(processingSetArtifactId); } catch (Exception ex) { throw new Exception("An error occured when creating Processing Set", ex); } }
public async Task TagDocumentsResponsiveAsync(int workspaceId, List <int> documentsToTag) { Console2.WriteDisplayStartLine("Tagging all documents as Responsive"); RsapiClient.APIOptions.WorkspaceID = workspaceId; foreach (int currentDocumentArtifactId in documentsToTag) { // Read the document Document currentDocumentRdo = await Task.Run(() => RsapiClient.Repositories.Document.ReadSingle(currentDocumentArtifactId)); // Code the document as Responsive currentDocumentRdo.Fields.Add(new FieldValue { Name = Constants.Workspace.ResponsiveField.Name, Value = Constants.Workspace.ResponsiveField.VALUE }); try { // Perform the document update WriteResultSet <Document> documentWriteResultSet = await Task.Run(() => RsapiClient.Repositories.Document.Update(currentDocumentRdo)); if (!documentWriteResultSet.Success) { Console2.WriteDebugLine($"Error: {documentWriteResultSet.Message} \r\n {documentWriteResultSet.Results[0].Message}"); Console2.WriteDebugLine(string.Join(";", documentWriteResultSet.Results)); throw new Exception("Failed to tag document as Responsive"); } Console2.WriteDebugLine($"Tagged document as Responsive! [Name: {currentDocumentRdo.TextIdentifier}]"); } catch (Exception ex) { throw new Exception("An error occured when tagging document as Responsive", ex); } } Console2.WriteDisplayEndLine("Tagged all documents as Responsive!"); }
private static async Task CreateAndBuildDtSearch() { Console2.WriteStartHeader("Create Search"); Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); // Create Keyword Search int seedSearchId = await RESTSearchHelper.CreateKeywordSearchAsync(_httpClient, _workspaceArtifactId); // Create dtSearch Index _dtSearchIndexId = await RESTSearchHelper.CreateDtSearchIndexAsync(_httpClient, _workspaceArtifactId, seedSearchId); // Build dtSearch Index await RESTSearchHelper.BuildDtSearchIndexAsync(_httpClient, _workspaceArtifactId, _dtSearchIndexId); // Create dtSearch _dtSearchArtifactId = await RESTSearchHelper.CreateDtSearchAsync(_httpClient, _workspaceArtifactId, _dtSearchIndexId, Constants.Workspace.EXTRACTED_TEXT_FIELD_NAME); stopwatch.Stop(); DisplayTimeElapsed(stopwatch.Elapsed); }
public override async Task Execute() { Console2.White("Seeding Users... "); _db.Users.AddIfNotExists(m => m.Name == "Admin", new User { Name = "Admin", Email = "*****@*****.**", HashedPassword = Hash.Create("admin"), IsAdmin = true, ConfirmedAt = DateTime.Now }); Console2.GreenLine("✅"); Console2.White($"Seeding Providers... "); _db.Providers.AddIfNotExists(m => m.Name == "Four", new Provider { Name = "Four", Amounts = "10,20,30,50" }); _db.Providers.AddIfNotExists(m => m.Name == "Lemon", new Provider { Name = "Lemon", Amounts = "15,25,50" }); _db.Providers.AddIfNotExists(m => m.Name == "G-Mobile", new Provider { Name = "G-Mobile", Amounts = "10,15,20,30" }); Console2.GreenLine("✅"); await _db.SaveChangesAsync(); }
public static async Task <int> CreateCustodianAsync(HttpClient httpClient, int workspaceId) { try { string url = "Relativity.REST/api/Relativity.Processing.Services.IProcessingModule/Processing Custodian Manager/SaveAsync"; CustodianSaveRequest custodianSaveRequest = new CustodianSaveRequest { Custodian = new Custodian { DocumentNumberingPrefix = Constants.Processing.Custodian.DOCUMENT_NUMBERING_PREFIX, FirstName = Constants.Processing.Custodian.FIRST_NAME, LastName = Constants.Processing.Custodian.LAST_NAME, CustodianType = "Person" }, workspaceArtifactId = workspaceId }; string request = JsonConvert.SerializeObject(custodianSaveRequest); Console2.WriteDisplayStartLine($"Creating Custodian [FirstName: {Constants.Processing.Custodian.FIRST_NAME}, LastName: {Constants.Processing.Custodian.LAST_NAME}]"); HttpResponseMessage response = RESTConnectionManager.MakePost(httpClient, url, request); string result = await response.Content.ReadAsStringAsync(); bool success = HttpStatusCode.OK == response.StatusCode; if (!success) { throw new Exception("Failed to Create Custodian"); } int custodianArtifactId = Int32.Parse(result); Console2.WriteDebugLine($"Custodian ArtifactId: {custodianArtifactId}"); Console2.WriteDisplayEndLine("Created Custodian!"); return(custodianArtifactId); } catch (Exception ex) { throw new Exception("An error occured when creating Custodian", ex); } }
public static async Task <List <int> > GetDocumentsToTagAsync(HttpClient httpClient, int searchID, int workspaceID) { try { List <int> DocsToTag = new List <int>(); string url = $"/Relativity.REST/Workspace/{workspaceID}/Document/QueryResult"; string fields = "*"; GetDocs docsToTag = new GetDocs() { Condition = $"'ArtifactId' IN SAVEDSEARCH {searchID}", Fields = new string[] { fields } }; string request = JsonConvert.SerializeObject(docsToTag); Console2.WriteDisplayStartLine("Querying documents to Tag"); HttpResponseMessage response = RESTConnectionManager.MakePost(httpClient, url, request); string result = await response.Content.ReadAsStringAsync(); bool success = (HttpStatusCode.OK == response.StatusCode) || (HttpStatusCode.Created == response.StatusCode); if (!success) { throw new Exception("Failed to obtain documents."); } JObject resultObject = JObject.Parse(result); foreach (JToken token in resultObject["Results"]) { DocsToTag.Add(token["Artifact ID"].Value <int>()); } Console2.WriteDisplayEndLine($"Queried documents to Tag [Count: {DocsToTag.Count}]"); return(DocsToTag); } catch (Exception ex) { throw new Exception("An error occurred when Querying for documents to tag", ex); } }
private async Task <RelativityFileShare> GetFileShareAsync(IRelativityTransferHost relativityTransferHost, int number, CancellationToken cancellationToken) { Console2.WriteTapiStartHeader("Get Specified File Share"); IFileStorageSearch fileStorageSearch = relativityTransferHost.CreateFileStorageSearch(); // Admin rights are required but this allows searching for all possible file shares within the instance. FileStorageSearchContext context = new FileStorageSearchContext { WorkspaceId = Workspace.AdminWorkspaceId }; FileStorageSearchResults results = await fileStorageSearch.SearchAsync(context, cancellationToken).ConfigureAwait(false); // Specify the cloud-based logical file share number - or just the 1st file share when all else fails. RelativityFileShare fileShare = results.GetRelativityFileShare(number) ?? results.FileShares.FirstOrDefault(); if (fileShare == null) { throw new InvalidOperationException("This operation cannot be performed because there are no file shares available."); } DisplayFileShare(fileShare); Console2.WriteTapiEndHeader(); return(fileShare); }
private static async Task CreateAndRunImagingSetAsync() { Console2.WriteStartHeader("Imaging"); Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); // Perform another search for documents where responsive = yes int savedSearchId = await RESTSearchHelper.CreateDtSearchAsync(_httpClient, _workspaceArtifactId, _dtSearchIndexId, Constants.Workspace.ResponsiveField.Name); // Create Imaging Profile and Set int imagingProfileId = await RESTImagingHelper.CreateImagingProfileAsync(_httpClient, _workspaceArtifactId); int imagingSetId = await RESTImagingHelper.CreateImagingSetAsync(_httpClient, savedSearchId, imagingProfileId, _workspaceArtifactId); // Run Imaging Job await RESTImagingHelper.RunImagingJobAsync(_httpClient, imagingSetId, _workspaceArtifactId); await RESTImagingHelper.WaitForImagingJobToCompleteAsync(_httpClient, _workspaceArtifactId, imagingSetId); stopwatch.Stop(); DisplayTimeElapsed(stopwatch.Elapsed); }
public override bool Execute(Input input) { var make = new Maker(_solution); Console2.BreakLine(); if (input.Template.IsEmpty()) { Console2.YellowLine("Choose one of the templates passing the flag:"); Console2.WhiteLine("--new"); Console2.WhiteLine("--show"); Console2.WhiteLine("--list"); Console2.WhiteLine("--edit"); return(false); } make.Feature(input.In, input.Name, input.Action, input.Template); Console2.BreakLine(); return(true); }
public async Task StartPublishJobAsync(int processingSetArtifactId, int workspaceArtifactId) { try { Console2.WriteDisplayStartLine("Starting Publish Job"); // Create a publish job object. PublishJob publishJob = new PublishJob { ProcessingSetId = processingSetArtifactId, WorkspaceArtifactId = workspaceArtifactId }; // Submit the job for publish. await ProcessingJobManager.SubmitPublishJobsAsync(publishJob); Console2.WriteDisplayEndLine("Started Publish Job!"); } catch (Exception ex) { throw new Exception("An error occured when staring Processing Publish Job", ex); } }
public static async Task CheckProductionStatusAsync(HttpClient httpClient, int productionId, int workspaceId) { try { string url = $"/Relativity.REST/api/Relativity.Productions.Services.IProductionModule/Production%20Manager/ReadSingleAsync"; string productionStatus = "Staged"; ReadProductionRequest readProductionRequest = new ReadProductionRequest() { DataSourceReadMode = 0, productionArtifactID = productionId, workspaceArtifactID = workspaceId }; string request = JsonConvert.SerializeObject(readProductionRequest); Console2.WriteDisplayStartLine("Waiting for Production Job to finish"); while (productionStatus != "Produced") { HttpResponseMessage response = RESTConnectionManager.MakePost(httpClient, url, request); string result = await response.Content.ReadAsStringAsync(); bool success = HttpStatusCode.OK == response.StatusCode; if (!success) { throw new Exception("Failed to read production set."); } JToken productionReadResults = JToken.Parse(result); var test2 = productionReadResults["ProductionMetadata"]; productionStatus = test2["Status"].Value <string>(); } Console2.WriteDisplayEndLine("Production Job Complete!"); } catch (Exception ex) { throw new Exception("Production Job failed to Complete", ex); } }
public async Task <int> CreateProcessingSetAsync(int processingProfileArtifactId, int workspaceArtifactId) { try { Console2.WriteDisplayStartLine($"Creating Processing Set [Name: {Constants.Processing.Set.NAME}]"); //Build the ProcessingSet object. ProcessingSet processingSet = new ProcessingSet { ArtifactID = Constants.Processing.Set.ARTIFACT_ID, Name = Constants.Processing.Set.NAME, Profile = new ProcessingProfileRef(processingProfileArtifactId) }; if (Constants.Processing.Set.EmailNotificationRecipients.Length > 0) { processingSet.EmailNotificationRecipients = Constants.Processing.Set.EmailNotificationRecipients; } //Create the ProcessingSet object. The service returns the Artifact ID of the object. int processingSetArtifactId = await ProcessingSetManager.SaveAsync(processingSet, workspaceArtifactId); if (processingSetArtifactId == 0) { throw new Exception("Failed to Create Processing Set"); } Console2.WriteDebugLine($"Processing Set ArtifactId: {processingSetArtifactId}"); Console2.WriteDisplayEndLine("Created Processing Set!"); return(processingSetArtifactId); } catch (Exception ex) { throw new Exception("An error occured when creating Processing Set", ex); } }
private static async Task CreateAndBuildDtSearch() { Console2.WriteStartHeader("Create Search"); Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); SearchHelper searchHelper = new SearchHelper(_connectionManager.KeywordSearchManager, _connectionManager.DtSearchManager, _connectionManager.DtSearchIndexManager, _connectionManager.RsapiClient); // Create Keyword Search int keywordSearchArtifactId = await searchHelper.CreateKeywordSearchAsync(_workspaceArtifactId); // Create dtSearch Index int dtSearchIndexArtifactId = await searchHelper.CreateDtSearchIndexAsync(_workspaceArtifactId, keywordSearchArtifactId); // Build dtSearch index await searchHelper.BuildDtSearchIndexAsync(_workspaceArtifactId, dtSearchIndexArtifactId); // Create dtSearch _dtSearchArtifactId = await searchHelper.CreateDtSearchAsync(_workspaceArtifactId, Constants.Workspace.EXTRACTED_TEXT_FIELD_NAME); stopwatch.Stop(); DisplayTimeElapsed(stopwatch.Elapsed); }
public Task Execute() { var services = _services.Where(x => !x.ServiceType.Namespace.StartsWith("Microsoft") && !x.ServiceType.Namespace.StartsWith("System")); // if (input.Namespace.NotEmpty()) services = services.Where(x => x.ServiceType.Namespace.StartsWith("Mediat") || x.ServiceType.Namespace.StartsWith("Miru") || x.ServiceType.Namespace.StartsWith("Intanext")) .OrderBy(x => x.ServiceType.FullName); foreach (var service in services) { Console2.WhiteLine(service.ServiceType.FullName); Console2.White("\t"); Console2.WhiteLine(service.Lifetime.ToString()); Console2.White("\t"); Console2.WhiteLine(service.ImplementationType?.FullName ?? "None"); } return(Task.CompletedTask); }
public async Task <List <int> > GetDocumentsToTagAsync(int searchArtifactId, int workspaceArtifactId) { Console2.WriteDisplayStartLine("Querying documents to Tag"); RsapiClient.APIOptions.WorkspaceID = workspaceArtifactId; List <int> documentsToTag = new List <int>(); Query <Document> documentQuery = new Query <Document> { Condition = new SavedSearchCondition(searchArtifactId), Fields = FieldValue.AllFields }; ResultSet <Document> docResults = await Task.Run(() => RsapiClient.Repositories.Document.Query(documentQuery)); foreach (Result <Document> singleDoc in docResults.Results) { // This loop will add the artifactID of each document that met our search Criteria and as such should be tagged responsive or w/e documentsToTag.Add(singleDoc.Artifact.ArtifactID); } Console2.WriteDisplayEndLine($"Queried documents to Tag [Count: {documentsToTag.Count}]"); return(documentsToTag); }
//This should cover profile, custodians, processing sets, inventory job, discovery, publish public async Task <int> CreateProcessingProfileAsync(int timeZoneArtifactId, int destinationFolderArtifactId, int workspaceArtifactId) { try { Console2.WriteDisplayStartLine($"Creating Processing Profile [Name: {Constants.Processing.Profile.NAME}]"); // Build Basic Processing Profile ProcessingProfile processingProfile = BuildBasicProfile(timeZoneArtifactId, destinationFolderArtifactId); //Build the ProcessingProfileSaveRequest ProcessingProfileSaveRequest processingProfileSaveRequest = new ProcessingProfileSaveRequest { ProcessingProfile = processingProfile, WorkspaceId = workspaceArtifactId }; //Create the ProcessingProfile object. The service returns a ProcessingProfileSaveResponse object. ProcessingProfileSaveResponse saveResponse = await ProcessingProfileManager.SaveAsync(processingProfileSaveRequest); int processingProfileArtifactId = saveResponse.ProcessingProfileId; if (processingProfileArtifactId == 0) { throw new Exception("Failed to Create Processing Profile"); } Console2.WriteDebugLine($"Processing Profile ArtifactId: {processingProfileArtifactId}"); Console2.WriteDisplayEndLine("Created Processing Profile!"); return(processingProfileArtifactId); } catch (Exception ex) { // Error Creating Processing Profile throw new Exception("An error occured when creating Processing Profile", ex); } }
public static async Task MainAsync(string[] args) { try { _httpClient = RESTConnectionManager.GetHttpClient(); _connectionManager = new ConnectionManager(); await CleanupWorkspacesAsync(); await CreateWorkspaceAsync(); await TransferDocumentsAsync(); await CreateAndRunProcessingSetAsync(); await CreateAndBuildDtSearch(); await TagDocumentsAsResponsiveAsync(); await CreateAndRunImagingSetAsync(); await CreateAndRunProductionAsync(); await DownloadProductionAsync(); } catch (Exception ex) { string errorMessage = $"An error occured in the {nameof(MainAsync)} method."; Console2.WriteErrorLine(errorMessage); throw new Exception(errorMessage, ex); } finally { await DeleteWorkspaceAsync(); } }
public static async Task <int> CreateProcessingProfileAsync(HttpClient httpClient, int timeZoneArtifactId, int destinationFolderArtifactId, int workspaceId) { try { string url = "Relativity.REST/api/Relativity.Processing.Services.IProcessingModule/Processing Profile Manager/SaveAsync"; ProcessingProfileSaveRequestStructure processingProfileSaveRequestStructure = new ProcessingProfileSaveRequestStructure { ProcessingProfileSaveRequest = new ProcessingProfileSaveRequest { ProcessingProfile = new ProcessingProfile { Name = Constants.Processing.Profile.NAME, NumberingSettings = new NumberingSettings { DefaultDocumentNumberingPrefix = Constants.Processing.Profile.DEFAULT_DOCUMENT_NUMBERING_PREFIX, NumberofDigits = Constants.Processing.Profile.NUMBER_OF_DIGITS4_AS_STRING, NumberingType = Constants.Processing.Profile.NUMBERING_TYPE_AS_STRING, ParentChildNumbering = Constants.Processing.Profile.PARENT_CHILD_NUMBERING_AS_STRING, Delimiter = Constants.Processing.Profile.DELIMITER, }, DeduplicationSettings = new DeduplicationSettings { DeduplicationMethod = Constants.Processing.Profile.DE_DUPLICATION_METHOD_AS_STRING, PropagateDeduplicationData = Constants.Processing.Profile.PROPAGATE_DE_DUPLICATION_DATA }, ExtractionSettings = new ExtractionSettings { Extractchildren = Constants.Processing.Profile.EXTRACT_CHILDREN, EmailOutput = Constants.Processing.Profile.EMAIL_OUTPUT_AS_STRING, ExcelTextExtractionMethod = Constants.Processing.Profile.EXCEL_TEXT_EXTRACTION_METHOD_AS_STRING, ExcelHeaderFooterExtraction = Constants.Processing.Profile.EXCEL_HEADER_FOOTER_EXTRACTION_AS_STRING, PowerPointTextExtractionMethod = Constants.Processing.Profile.POWER_POINT_TEXT_EXTRACTION_METHOD_AS_STRING, WordTextExtractionMethod = Constants.Processing.Profile.WORD_TEXT_EXTRACTION_METHOD_AS_STRING, OCR = Constants.Processing.Profile.OCR, OCRAccuracy = Constants.Processing.Profile.OCR_ACCURACY_AS_STRING, OCRTextSeparator = Constants.Processing.Profile.OCR_TEXT_SEPARATOR }, InventoryDiscoverSettings = new InventoryDiscoverSettings { DeNIST = Constants.Processing.Profile.DE_NIST, DefaultTimeZoneID = timeZoneArtifactId, DefaultOCRlanguages = Constants.Processing.Profile.DEFAULT_OCR_LANGUAGES }, PublishSettings = new PublishSettings { AutopublishSet = Constants.Processing.Profile.AUTO_PUBLISH_SET, DefaultDestinationFolder = new DefaultDestinationFolder { ArtifactID = destinationFolderArtifactId }, UseSourceFolderStructure = Constants.Processing.Profile.USE_SOURCE_FOLDER_STRUCTURE } }, WorkspaceId = workspaceId } }; string request = JsonConvert.SerializeObject(processingProfileSaveRequestStructure); Console2.WriteDisplayStartLine($"Creating Processing Profile [Name: {Constants.Processing.Profile.NAME}]"); HttpResponseMessage response = RESTConnectionManager.MakePost(httpClient, url, request); string result = await response.Content.ReadAsStringAsync(); bool success = HttpStatusCode.OK == response.StatusCode; if (!success) { throw new Exception("Failed to Create Processing Profile"); } JObject resultObject = JObject.Parse(result); int processingProfileArtifactId = resultObject["ProcessingProfileId"].Value <int>(); Console2.WriteDebugLine($"Processing Profile ArtifactId: {processingProfileArtifactId}"); Console2.WriteDisplayEndLine("Created Processing Profile!"); return(processingProfileArtifactId); } catch (Exception ex) { throw new Exception("An error occured when creating Processing Profile", ex); } }
public override Task <bool> Handle(ConsoleCommandEvent <LogoConsoleCommand> request, CancellationToken cancellationToken) { Console2.WriteTextLogo(); return(Task.FromResult(true)); }
public void PrintConsole(string line) { Console2.Invoke(new TreeViewUpdateDelegate(delegate(string line1) { Console2.Nodes.Add(line1).EnsureVisible(); }), new object[] { line }); }
public static async Task <int> CreateProductionAsync(HttpClient httpClient, int workspaceId) { try { string url = $"/Relativity.REST/api/Relativity.Productions.Services.IProductionModule/Production%20Manager/CreateSingleAsync"; Production prodSettings = new Production() { Details = new Details() { BrandingFontSize = Constants.Production.BRANDING_FONT_SIZE, EmailRecipients = "", ScaleBrandingFont = false }, Footers = new Footers() { LeftFooter = new Leftfooter() { Type = "None", Field = new Field1() { ArtifactID = 0, Name = "", ViewFieldID = 0 }, FreeText = "", FriendlyName = "Left Header" } }, Headers = new Headers() { LeftHeader = new Leftheader() { Type = "None", Field = new Field() { ArtifactID = 0, Name = "", ViewFieldID = 0 }, FreeText = "", FriendlyName = "Left Header" } }, Name = Constants.Production.NAME, Numbering = new Numbering() { AttachmentRelationalField = new Attachmentrelationalfield() { ArtifactID = 0, Name = "", ViewFieldID = 0 }, BatesPrefix = Constants.Production.BATES_PREFIX, BatesStartNumber = Constants.Production.BATES_START_NUMBER, BatesSuffix = Constants.Production.BATES_SUFFIX, NumberOfDigitsForDocumentNumbering = Constants.Production.NUMBER_OF_DIGITS_FOR_DOCUMENT_NUMBERING, NumberingType = "PageLevel" }, ShouldCopyInstanceOnWorkspaceCreate = false, SortOrder = "" }; ProductionObject newProduction = new ProductionObject() { Production = prodSettings, workspaceArtifactID = workspaceId }; string request = JsonConvert.SerializeObject(newProduction); Console2.WriteDisplayStartLine($"Creating Production [Name: {Constants.Production.NAME}]"); HttpResponseMessage response = RESTConnectionManager.MakePost(httpClient, url, request); string result = response.Content.ReadAsStringAsync().Result; bool success = HttpStatusCode.OK == response.StatusCode; if (!success) { throw new Exception("Failed to create production set."); } int productionArtifactId = Convert.ToInt32(result); Console2.WriteDebugLine($"Production ArtifactId: {productionArtifactId}"); Console2.WriteDisplayEndLine("Created Production!"); return(productionArtifactId); } catch (Exception ex) { throw new Exception("An error occured when creating Production", ex); } }
public async Task <int> CreateKeywordSearchAsync(int workspaceArtifactId) { Console2.WriteDisplayStartLine("Creating Keyword search for DtSearch Index"); try { SearchContainerRef searchFolder = new SearchContainerRef(); KeywordSearch keywordSearch = new KeywordSearch { Name = Constants.Search.KeywordSearch.NAME, SearchContainer = searchFolder }; // Get all the query fields available to the current user. SearchResultViewFields searchResultViewFields = await KeywordSearchManager.GetFieldsForSearchResultViewAsync(workspaceArtifactId, Constants.DOCUMENT_ARTIFACT_TYPE); // Set the owner to the current user, in this case "Admin, Relativity," or "0" for public. List <UserRef> searchOwners = await KeywordSearchManager.GetSearchOwnersAsync(workspaceArtifactId); keywordSearch.Owner = searchOwners.First(o => o.Name == Constants.Search.KeywordSearch.OWNER); // Add the fields to the Fields collection. // If a field Name, ArtifactID, Guid, or ViewFieldID is known, a field can be set with that information as well. FieldRef fieldRef = searchResultViewFields.FieldsNotIncluded.First(f => f.Name == Constants.Search.KeywordSearch.FIELD_EDIT); keywordSearch.Fields.Add(fieldRef); fieldRef = searchResultViewFields.FieldsNotIncluded.First(f => f.Name == Constants.Search.KeywordSearch.FIELD_FILE_ICON); keywordSearch.Fields.Add(fieldRef); fieldRef = searchResultViewFields.FieldsNotIncluded.First(f => f.Name == Constants.Search.KeywordSearch.FIELD_CONTROL_NUMBER); keywordSearch.Fields.Add(fieldRef); // Create a Criteria for the field named "Extracted Text" where the value is set Criteria criteria = new Criteria { Condition = new CriteriaCondition( new FieldRef { Name = Constants.Search.KeywordSearch.CONDITION_FIELD_EXTRACTED_TEXT }, CriteriaConditionEnum.IsSet) }; // Add the search condition criteria to the collection. keywordSearch.SearchCriteria.Conditions.Add(criteria); // Add a note. keywordSearch.Notes = Constants.Search.KeywordSearch.NOTES; keywordSearch.ArtifactTypeID = Constants.DOCUMENT_ARTIFACT_TYPE; // Create the search. int keywordSearchArtifactId = await KeywordSearchManager.CreateSingleAsync(workspaceArtifactId, keywordSearch); if (keywordSearchArtifactId == 0) { throw new Exception("Failed to create the Keyword Search"); } Console2.WriteDebugLine($"Keyword Search ArtifactId: {keywordSearchArtifactId}"); Console2.WriteDisplayEndLine("Created Keyword search for DtSearch Index!"); return(keywordSearchArtifactId); } catch (Exception ex) { throw new Exception("An error occured when creating Keyword Search", ex); } }
public async Task <int> CreateDtSearchAsync(int workspaceArtifactId, string fieldName) { Console2.WriteDisplayStartLine($"Creating DtSearch for Field [Name: {fieldName}]"); try { string searchName = Constants.Search.DtSearch.NAME; if (fieldName == Constants.Workspace.EXTRACTED_TEXT_FIELD_NAME) { searchName = Constants.Search.DtSearch.NAME_EXTRACTED_TEXT; } SearchContainerRef searchContainerRef = new SearchContainerRef(); dtSearch dtSearch = new dtSearch { Name = searchName, SearchContainer = searchContainerRef }; // Get all the query fields available to the current user. SearchResultViewFields searchResultViewFields = await DtSearchManager.GetFieldsForSearchResultViewAsync(workspaceArtifactId, Constants.DOCUMENT_ARTIFACT_TYPE); // Get a dtSearch SearchIndex and set it. List <SearchIndexRef> searchIndexes = await DtSearchManager.GetSearchIndexesAsync(workspaceArtifactId); dtSearch.SearchIndex = searchIndexes.FirstOrDefault(); // Set the owner to "Public". List <UserRef> searchOwners = await DtSearchManager.GetSearchOwnersAsync(workspaceArtifactId); dtSearch.Owner = searchOwners.First(o => o.Name == Constants.Search.DtSearch.OWNER); // Add the fields to the Fields collection. // If a field Name, ArtifactID, Guid, or ViewFieldID is known, a field can be set with that information as well. FieldRef field = searchResultViewFields.FieldsNotIncluded.First(f => f.Name == Constants.Search.DtSearch.FIELD_EDIT); dtSearch.Fields.Add(field); field = searchResultViewFields.FieldsNotIncluded.First(f => f.Name == Constants.Search.DtSearch.FIELD_FILE_ICON); dtSearch.Fields.Add(field); field = searchResultViewFields.FieldsNotIncluded.First(f => f.Name == Constants.Search.DtSearch.FIELD_CONTROL_NUMBER); dtSearch.Fields.Add(field); // Create a Criteria for the field named "Extracted Text" where the value is set Criteria criteria = new Criteria { Condition = new CriteriaCondition(new FieldRef { Name = fieldName }, CriteriaConditionEnum.IsSet) }; // Add the search condition criteria to the collection. dtSearch.SearchCriteria.Conditions.Add(criteria); // Search for the text string "John" with a fuzziness level of 5 and stemming enabled. //search.SearchText = "John"; //search.FuzzinessLevel = 5; //search.EnableStemming = true; // Add a note. dtSearch.Notes = Constants.Search.DtSearch.NOTES; dtSearch.ArtifactTypeID = Constants.DOCUMENT_ARTIFACT_TYPE; // Create the search. int dtSearchArtifactId = await DtSearchManager.CreateSingleAsync(workspaceArtifactId, dtSearch); if (dtSearchArtifactId == 0) { throw new Exception("Failed to create the DtSearch"); } Console2.WriteDebugLine($"DtSearch ArtifactId: {dtSearchArtifactId}"); Console2.WriteDisplayEndLine("Created DtSearch!"); return(dtSearchArtifactId); } catch (Exception ex) { throw new Exception("An error occured when creating DtSearch", ex); } }
public static async Task <int> CreateKeywordSearchAsync(HttpClient httpClient, int workspaceId) { try { string url = "Relativity.REST/api/Relativity.Services.Search.ISearchModule/Keyword Search Manager/CreateSingleAsync"; KeywordSearchCreateRequest keywordSearchCreateRequest = new KeywordSearchCreateRequest { workspaceArtifactID = workspaceId, searchDTO = new Searchdto { ArtifactTypeID = 10, Name = Constants.Search.KeywordSearch.NAME, SearchCriteria = new Searchcriteria { Conditions = new [] { new Condition { condition = new Condition1 { Operator = "Is Set", ConditionType = "Criteria", FieldIdentifier = new Fieldidentifier { Name = Constants.Search.KeywordSearch.CONDITION_FIELD_EXTRACTED_TEXT } } } } }, Fields = new [] { new Field { Name = "Edit" }, new Field { Name = "File Icon" }, new Field { Name = "Control Number" } } } }; string request = JsonConvert.SerializeObject(keywordSearchCreateRequest); Console2.WriteDisplayStartLine("Creating Keyword search for DtSearch Index"); HttpResponseMessage response = RESTConnectionManager.MakePost(httpClient, url, request); string result = await response.Content.ReadAsStringAsync(); bool success = HttpStatusCode.OK == response.StatusCode; if (!success) { throw new Exception("Failed to Create Keyword Search"); } int keywordSearchArtifactId = Int32.Parse(result); Console2.WriteDebugLine($"Keyword Search ArtifactId: {keywordSearchArtifactId}"); Console2.WriteDisplayEndLine("Created Keyword search for DtSearch Index!"); return(keywordSearchArtifactId); } catch (Exception ex) { throw new Exception("An error occured when creating Keyword Search", ex); } }
public static async Task <int> CreateDtSearchAsync(HttpClient httpClient, int workspaceId, int dtSearchIndexId, string fieldName) { try { string url = "Relativity.REST/api/Relativity.Services.Search.ISearchModule/dtSearch Manager/CreateSingleAsync"; string searchName = Constants.Search.DtSearch.NAME; if (fieldName == Constants.Workspace.EXTRACTED_TEXT_FIELD_NAME) { searchName = Constants.Search.DtSearch.NAME_EXTRACTED_TEXT; } DtSearchSaveRequest dtSearchSaveRequest = new DtSearchSaveRequest { workspaceArtifactID = workspaceId, searchDTO = new searchdto { ArtifactTypeID = 10, Name = searchName, SearchIndex = new searchindex { ArtifactID = dtSearchIndexId, Name = Constants.Search.DtSearchIndex.NAME }, SearchCriteria = new searchcriteria { Conditions = new [] { new condition { condition1 = new condition1 { Operator = "Is Set", ConditionType = "Criteria", FieldIdentifier = new fieldidentifier { Name = fieldName } } }, } }, Fields = new [] { new Fields { Name = "Edit" }, new Fields { Name = "File Icon" }, new Fields { Name = "Control Number" } } } }; string request = JsonConvert.SerializeObject(dtSearchSaveRequest); Console2.WriteDisplayStartLine($"Creating DtSearch for Field [Name: {fieldName}]"); HttpResponseMessage response = RESTConnectionManager.MakePost(httpClient, url, request); string result = await response.Content.ReadAsStringAsync(); bool success = HttpStatusCode.OK == response.StatusCode; if (!success) { throw new Exception("Failed to Create dtSearch"); } int dtSearchArtifactId = Int32.Parse(result); Console2.WriteDebugLine($"DtSearch ArtifactId: {dtSearchArtifactId}"); Console2.WriteDisplayEndLine("Created DtSearch!"); return(dtSearchArtifactId); } catch (Exception ex) { throw new Exception("An error occured when creating DtSearch", ex); } }
private async Task UploadMultipleDocumentsAsync(IRelativityTransferHost relativityTransferHost, CancellationToken cancellationToken) { // Search for the first logical file share. const int logicalFileShareNumber = 1; RelativityFileShare fileShare = await GetFileShareAsync(relativityTransferHost, logicalFileShareNumber, cancellationToken).ConfigureAwait(false); // Configure an Aspera specific transfer. AsperaClientConfiguration configuration = CreateAsperaClientConfiguration(); // Assigning the file share bypasses auto-configuration that will normally use the default workspace repository. configuration.TargetFileShare = fileShare; using (ITransferClient client = await CreateClientAsync(relativityTransferHost, configuration, cancellationToken).ConfigureAwait(false)) using (AutoDeleteDirectory directory = new AutoDeleteDirectory()) { // Create a job-based upload transfer request. Console2.WriteTapiStartHeader("Advanced Transfer - Upload"); string uploadTargetPath = GetUniqueRemoteTargetPath(fileShare); IList <TransferPath> localSourcePaths = await SearchLocalSourcePathsAsync(client, uploadTargetPath, cancellationToken).ConfigureAwait(false); TransferContext context = CreateTransferContext(); TransferRequest uploadJobRequest = TransferRequest.ForUploadJob(uploadTargetPath, context); uploadJobRequest.Application = "Github Sample"; uploadJobRequest.Name = "Advanced Upload Sample"; // Create a transfer job to upload the local sample data set to the target remote path. using (ITransferJob job = await client.CreateJobAsync(uploadJobRequest, cancellationToken).ConfigureAwait(false)) { Console2.WriteDebugLine("Advanced upload started."); // Paths added to the async job are transferred immediately. await job.AddPathsAsync(localSourcePaths, cancellationToken).ConfigureAwait(false); // Await completion of the job. ITransferResult result = await job.CompleteAsync(cancellationToken).ConfigureAwait(false); Console2.WriteDebugLine("Advanced upload completed."); DisplayTransferResult(result); Console2.WriteTapiEndHeader(); } // Create a job-based download transfer request. Console2.WriteTapiStartHeader("Advanced Transfer - Download"); string downloadTargetPath = directory.Path; TransferRequest downloadJobRequest = TransferRequest.ForDownloadJob(downloadTargetPath, context); downloadJobRequest.Application = "Github Sample"; downloadJobRequest.Name = "Advanced Download Sample"; Console2.WriteDebugLine("Advanced download started."); // Create a transfer job to download the sample data set to the target local path. using (ITransferJob job = await client.CreateJobAsync(downloadJobRequest, cancellationToken).ConfigureAwait(false)) { IEnumerable <TransferPath> remotePaths = localSourcePaths.Select(localPath => new TransferPath { SourcePath = uploadTargetPath + "\\" + Path.GetFileName(localPath.SourcePath), PathAttributes = TransferPathAttributes.File, TargetPath = downloadTargetPath }); await job.AddPathsAsync(remotePaths, cancellationToken).ConfigureAwait(false); await ChangeDataRateAsync(job, cancellationToken).ConfigureAwait(false); // Await completion of the job. ITransferResult result = await job.CompleteAsync(cancellationToken).ConfigureAwait(false); Console2.WriteDebugLine("Advanced download completed."); DisplayTransferResult(result); Console2.WriteTapiEndHeader(); } } }
private static void DisplayTimeElapsed(TimeSpan stopwatchElapsed, string prefix = null) { Console2.WriteDisplayStartLine($"{prefix ?? string.Empty}Time elapsed: {stopwatchElapsed:hh\\:mm\\:ss}"); Console2.WriteDisplayEmptyLine(); }
public void CleanConsole() { Console2.Invoke(new TreeViewCleanDelegate(delegate { Console2.Nodes.Clear(); })); }