public static void UpdateJobField(IServicesMgr servicesMgr, int workspaceArtifactId, int jobArtifactId, Guid fieldGuid, object fieldValue) { try { using (IRSAPIClient rsapiClient = servicesMgr.CreateProxy <IRSAPIClient>(ExecutionIdentity.System)) { rsapiClient.APIOptions.WorkspaceID = workspaceArtifactId; RDO jobRdo = new RDO(jobArtifactId); jobRdo.ArtifactTypeGuids.Add(Constants.Guids.ObjectType.InstanceMetricsJob); jobRdo.Fields.Add(new FieldValue(fieldGuid, fieldValue)); try { rsapiClient.Repositories.RDO.UpdateSingle(jobRdo); } catch (Exception ex) { throw new Exception($"{Constants.ErrorMessages.UPDATE_APPLICATION_JOB_STATUS_ERROR}. UpdateSingle. [{nameof(workspaceArtifactId)}= {workspaceArtifactId}, {nameof(jobArtifactId)}= {jobArtifactId}, {nameof(fieldGuid)}= {fieldGuid}, {nameof(fieldValue)}= {fieldValue}]", ex); } } } catch (Exception ex) { throw new Exception(Constants.ErrorMessages.UPDATE_APPLICATION_JOB_STATUS_ERROR, ex); } }
/// <summary> /// Check to see if passed in credentials via Header Authentication is valid /// </summary> /// <param name="serviceManager"></param> /// <returns></returns> public async Task <string> RequestAuthTokenAsync(IServicesMgr serviceManager) { string retVal = null; using (IRSAPIClient rsapiClient = serviceManager.CreateProxy <IRSAPIClient>(ExecutionIdentity.System)) { try { rsapiClient.APIOptions = new APIOptions { WorkspaceID = -1 }; var readResult = await Task.Run(() => rsapiClient.GenerateRelativityAuthenticationToken(rsapiClient.APIOptions)); if (readResult.Success) { retVal = readResult.Artifact.getFieldByName("AuthenticationToken").ToString(); } else { _logHelper.LogError($"DAPI - {nameof(RequestAuthTokenAsync)} - Unable to receive authorization token"); } } catch (Exception ex) { _logHelper.LogError(ex, $"DAPI - {nameof(RequestAuthTokenAsync)} - Error while requesting authorization token: {ex}"); } } return(retVal); }
public static Int32 Query_For_Saved_SearchID(string savedSearchName, IRSAPIClient _client) { int searchArtifactId = 0; var query = new Query { ArtifactTypeID = (Int32)ArtifactType.Search, Condition = new TextCondition("Name", TextConditionEnum.Like, savedSearchName) }; QueryResult result = null; try { result = _client.Query(_client.APIOptions, query); } catch (Exception ex) { Console.WriteLine("An error occurred: {0}", ex.Message); } if (result != null) { searchArtifactId = result.QueryArtifacts[0].ArtifactID; } return(searchArtifactId); }
protected RelativityFile GetFile(int fileFieldArtifactId, int ourFileContainerInstanceArtifactId) { using (IRSAPIClient proxyToWorkspace = CreateProxy()) { try { var fileRequest = new FileRequest(proxyToWorkspace.APIOptions); fileRequest.Target.FieldId = fileFieldArtifactId; fileRequest.Target.ObjectArtifactId = ourFileContainerInstanceArtifactId; RelativityFile returnValue; var fileData = invokeWithRetryService.InvokeWithRetry(() => proxyToWorkspace.Download(fileRequest)); using (MemoryStream ms = (MemoryStream)fileData.Value) { FileValue fileValue = new FileValue(null, ms.ToArray()); FileMetadata fileMetadata = fileData.Key.Metadata; returnValue = new RelativityFile(fileFieldArtifactId, fileValue, fileMetadata); } return(returnValue); } catch (Exception ex) { throw new ProxyOperationFailedException("Failed in method: " + System.Reflection.MethodInfo.GetCurrentMethod(), ex); } } }
public static Int32 ImportApplication(IRSAPIClient client, Int32 workspaceId, bool forceFlag, string filePath, string applicationName, int appArtifactID = -1) { int artifactID = 0; ImportApplication(client, workspaceId, forceFlag, filePath, appArtifactID); Console.WriteLine("Querying for Application artifact id...."); var query = new Query <kCura.Relativity.Client.DTOs.RelativityApplication>(); query.Fields.Add(new FieldValue(RelativityApplicationFieldNames.Name)); query.Condition = new TextCondition(RelativityApplicationFieldNames.Name, TextConditionEnum.EqualTo, applicationName); var queryResultSet = client.Repositories.RelativityApplication.Query(query); if (queryResultSet != null) { var result = queryResultSet.Results.FirstOrDefault(); if (result == null || result.Artifact == null) { throw new ApplicationInstallException($"Could not find application with name {applicationName}."); } artifactID = result.Artifact.ArtifactID; Console.WriteLine("Application artifactid is " + artifactID); } Console.WriteLine("Exiting Import Application method....."); return(artifactID); }
private static int FindClientArtifactId(IRSAPIClient rsapiClient, string group) { int artifactId = 0; TextCondition clientCondition = new TextCondition(ClientFieldNames.Name, TextConditionEnum.EqualTo, group); Query <Client> queryClient = new Query <Client> { Condition = clientCondition, Fields = FieldValue.AllFields }; try { QueryResultSet <Client> resultSetClient = rsapiClient.Repositories.Client.Query(queryClient, 0); if (resultSetClient.Success && resultSetClient.Results.Count == 1) { artifactId = resultSetClient.Results.FirstOrDefault().Artifact.ArtifactID; } else { Console.WriteLine("The Query operation failed.{0}{1}", Environment.NewLine, resultSetClient.Message); } } catch (Exception ex) { Console.WriteLine($"An error occurred: {ex.Message}"); } return(artifactId); }
public KeyValuePair <byte[], kCura.Relativity.Client.FileMetadata> DownloadDocumentNative(int documentId) { kCura.Relativity.Client.DTOs.Document doc = new kCura.Relativity.Client.DTOs.Document(documentId); byte[] documentBytes; KeyValuePair <DownloadResponse, Stream> documentNativeResponse = new KeyValuePair <DownloadResponse, Stream>(); using (IRSAPIClient proxy = CreateProxy()) { try { documentNativeResponse = invokeWithRetryService.InvokeWithRetry(() => proxy.Repositories.Document.DownloadNative(doc)); } catch (Exception ex) { throw new ProxyOperationFailedException("Failed in method: " + System.Reflection.MethodInfo.GetCurrentMethod(), ex); } } using (MemoryStream ms = (MemoryStream)documentNativeResponse.Value) { documentBytes = ms.ToArray(); } return(new KeyValuePair <byte[], FileMetadata>(documentBytes, documentNativeResponse.Key.Metadata)); }
public static int CreateDocumentFieldArticleTitle(IRSAPIClient proxy, int workspaceId) { Field createField = new Field() { Name = "Article Title", FieldTypeID = FieldType.LongText, IsRequired = false, Unicode = true, OpenToAssociations = true, Linked = false, AllowSortTally = true, Wrapping = true, AllowGroupBy = true, AllowPivot = true, IgnoreWarnings = true, IncludeInTextIndex = false, AvailableInViewer = false, AllowHTML = false, Width = "123", ObjectType = new ObjectType { DescriptorArtifactTypeID = 10 } }; proxy.APIOptions.WorkspaceID = workspaceId; int artifactIdCreatedField = proxy.Repositories.Field.CreateSingle(createField); return(artifactIdCreatedField); }
public static bool Delete_Group(IRSAPIClient client, int artifactId) { var clientID = client.APIOptions.WorkspaceID; client.APIOptions.WorkspaceID = -1; Group groupToDelete = new Group(artifactId); WriteResultSet <Group> resultSet = new WriteResultSet <Group>(); try { resultSet = client.Repositories.Group.Delete(groupToDelete); if (!resultSet.Success || resultSet.Results.Count == 0) { throw new Exception("Group not found in Relativity"); } } catch (Exception e) { Console.WriteLine("Group deletion threw an exception" + e); return(false); } client.APIOptions.WorkspaceID = clientID; return(true); }
static DTOs.Folder CreateFolder(DTOs.Folder source, int parent, IRSAPIClient client) { source.Name = source.Name; source.ParentArtifact = new DTOs.Artifact(parent); DTOs.WriteResultSet <DTOs.Folder> results; try { results = client.Repositories.Folder.Create(source); } catch (Exception ex) { //Console.WriteLine("An error occurred: {0}", ex.Message); return(null); } if (!results.Success) { //Console.WriteLine("Error: " + results.Results.FirstOrDefault().Message); return(null); } else { //Console.Write("{0} folder created successfully.\r\n", source.Name); return(results.Results.FirstOrDefault().Artifact); } }
private void SetupRsapiHelper() { try { APIOptions rsapiApiOptions = new APIOptions { WorkspaceID = -1 }; IRSAPIClient rsapiClient = Helper.GetServicesManager().CreateProxy <IRSAPIClient>(ExecutionIdentity.System); rsapiClient.APIOptions = rsapiApiOptions; IGenericRepository <RDO> rdoRepository = rsapiClient.Repositories.RDO; IGenericRepository <Choice> choiceRepository = rsapiClient.Repositories.Choice; IGenericRepository <Workspace> workspaceRepository = rsapiClient.Repositories.Workspace; IGenericRepository <kCura.Relativity.Client.DTOs.User> userRepository = rsapiClient.Repositories.User; IGenericRepository <Group> groupRepository = rsapiClient.Repositories.Group; _rsapiHelper = new RsapiHelper( rsapiApiOptions: rsapiApiOptions, rdoRepository: rdoRepository, choiceRepository: choiceRepository, workspaceRepository: workspaceRepository, userRepository: userRepository, groupRepository: groupRepository); } catch (Exception ex) { throw new Exception(Constants.ErrorMessages.RSAPI_HELPER_SETUP_ERROR, ex); } }
public static void CreateFolders(List <DTOs.Result <DTOs.Folder> > folders, IRSAPIClient client) { // store all top-level folders List <DTOs.Result <DTOs.Folder> > topLevel = folders.FindAll(x => x.Artifact.ParentArtifact.ArtifactID == _templateRootFolder); // create all top-level folders foreach (DTOs.Result <DTOs.Folder> f in topLevel) { DTOs.Folder current = f.Artifact; DTOs.Folder newFolder = CreateFolder(f.Artifact, (int)_targetRootFolder, client); if (newFolder != null) { // add to running total of created folders _createdFolders.Add(current); // remove from list of folders to create folders.Remove(f); // if there are more folders to create, recurse if (folders.Count > 0) { CheckForChildren(current, newFolder, folders, client); } } else { WorkspaceCreate.retVal.Message = String.Format("Error occurred creating folder {0}", f.Artifact.Name); } } //_logger.LogDebug(String.Format("\r\n{0} total folders created.", _createdFolders.Count)); }
public void Execute_TestFixtureSetup() { //Setup for testing //Setup for testing TestHelper helper = new TestHelper(); servicesManager = helper.GetServicesManager(); // implement_IHelper //create client _client = helper.GetServicesManager().GetProxy <IRSAPIClient>(ConfigurationHelper.ADMIN_USERNAME, ConfigurationHelper.DEFAULT_PASSWORD); _eddsDbContext = helper.GetDBContext(-1); //Create workspace _workspaceId = CreateWorkspace.CreateWorkspaceAsync(_workspaceName, ConfigurationHelper.TEST_WORKSPACE_TEMPLATE_NAME, servicesManager, ConfigurationHelper.ADMIN_USERNAME, ConfigurationHelper.DEFAULT_PASSWORD).Result; dbContext = helper.GetDBContext(_workspaceId); _client.APIOptions.WorkspaceID = _workspaceId; _rootFolderArtifactId = APIHelpers.GetRootFolderArtifactID(_client, _workspaceName); //Import Application containing script, fields, and choices Relativity.Test.Helpers.Application.ApplicationHelpers.ImportApplication(_client, _workspaceId, true, FilepathData); //Import custodians var custodians = GetCustodiansDatatable(); var identityFieldArtifactId = GetArtifactIDOfCustodianField("Full Name", _workspaceId, _client); ImportAPIHelpers.ImportObjects(_workspaceId, "Custodian", identityFieldArtifactId, custodians, String.Empty); //Import Documents var documents = GetDocumentDataTable(_rootFolderArtifactId, _workspaceId); ImportAPIHelpers.CreateDocuments(_workspaceId, _rootFolderArtifactId, documents); }
public static Int32 GetFieldArtifactID(String fieldname, Int32 workspaceID, IRSAPIClient _client) { int fieldArtifactId = 0; var query = new Query { ArtifactTypeID = (Int32)ArtifactType.Field, Condition = new TextCondition("Name", TextConditionEnum.Like, fieldname) }; QueryResult result = null; try { result = _client.Query(_client.APIOptions, query); } catch (Exception ex) { Console.WriteLine("An error occurred: {0}", ex.Message); } if (result != null) { fieldArtifactId = result.QueryArtifacts[0].ArtifactID; } return(fieldArtifactId); }
/// <summary> /// This creates the YAML file in the specified dir and uploads it /// </summary> /// <param name="result"></param> private void UploadYamlFileToResources(ParseSqlResult result) { File.WriteAllText(_yamlFullFilePath, result.Yaml); using (IRSAPIClient rsapiClient = GetServiceFactory().CreateProxy <IRSAPIClient>()) { ResourceFileRequest rfRequest = new ResourceFileRequest(); rfRequest.FullFilePath = _yamlFullFilePath; rfRequest.AppGuid = new Guid(DefaultAppGuid); rfRequest.FileName = Path.GetFileName(_yamlFullFilePath); try { rsapiClient.PushResourceFiles(rsapiClient.APIOptions, new List <ResourceFileRequest>() { rfRequest }); Console.WriteLine($"{nameof(UploadYamlFileToResources)} - Local YAML file ({_yamlFullFilePath}) - was uploaded successfully"); } catch (Exception ex) { Console.WriteLine($"{nameof(UploadYamlFileToResources)} - Could not upload ({_yamlFullFilePath}) - Exception: {ex.Message}"); } } }
public ImagingHelper(IImagingProfileManager imagingProfileManager, IImagingSetManager imagingSetManager, IImagingJobManager imagingJobManager, IRSAPIClient rsapiClient) { ImagingProfileManager = imagingProfileManager; ImagingSetManager = imagingSetManager; ImagingJobManager = imagingJobManager; RsapiClient = rsapiClient; }
private static int FindGroupArtifactId(IRSAPIClient rsapiClient, string group) { int artifactId = 0; TextCondition groupCondition = new TextCondition(GroupFieldNames.Name, TextConditionEnum.EqualTo, group); Query <Group> queryGroup = new Query <Group> { Condition = groupCondition }; queryGroup.Fields.Add(new FieldValue(ArtifactQueryFieldNames.ArtifactID)); try { QueryResultSet <Group> resultSetGroup = rsapiClient.Repositories.Group.Query(queryGroup, 0); if (resultSetGroup.Success && resultSetGroup.Results.Count == 1) { artifactId = resultSetGroup.Results.FirstOrDefault().Artifact.ArtifactID; } else { Console.WriteLine("The Query operation failed.{0}{1}", Environment.NewLine, resultSetGroup.Message); } } catch (Exception ex) { Console.WriteLine($"An error occurred: {ex.Message}"); } return(artifactId); }
public bool DeleteUploadedRequestsFromRelativity(IRSAPIClient proxy, int workspaceID, List <WikitivityUploadsAgent.SingleRequestObject> listOfCompletedUploads) { proxy.APIOptions.WorkspaceID = workspaceID; bool success = false; try { List <Document> DocsToDelete = new List <Document>(); foreach (var singleDoc in listOfCompletedUploads) { DocsToDelete.Add(new Document(singleDoc.ArtifactID)); } var DeleteResultSet = proxy.Repositories.Document.Delete(DocsToDelete); if (DeleteResultSet.Success) { success = true; } } catch (Exception ex) { throw new Exception("An error an occurred when deleting completed requests", ex); } return(success); }
private static int FindChoiceArtifactId(IRSAPIClient rsapiClient, int choiceType, string value) { int artifactId = 0; WholeNumberCondition choiceTypeCondition = new WholeNumberCondition(ChoiceFieldNames.ChoiceTypeID, NumericConditionEnum.EqualTo, (int)choiceType); TextCondition choiceNameCondition = new TextCondition(ChoiceFieldNames.Name, TextConditionEnum.EqualTo, value); CompositeCondition choiceCompositeCondition = new CompositeCondition(choiceTypeCondition, CompositeConditionEnum.And, choiceNameCondition); Query <kCura.Relativity.Client.DTOs.Choice> choiceQuery = new Query <kCura.Relativity.Client.DTOs.Choice>( new List <FieldValue> { new FieldValue(ArtifactQueryFieldNames.ArtifactID) }, choiceCompositeCondition, new List <Sort>()); try { QueryResultSet <kCura.Relativity.Client.DTOs.Choice> choiceQueryResult = rsapiClient.Repositories.Choice.Query(choiceQuery); if (choiceQueryResult.Success && choiceQueryResult.Results.Count == 1) { artifactId = choiceQueryResult.Results.FirstOrDefault().Artifact.ArtifactID; } else { Console.WriteLine("The choice could not be found."); } } catch (Exception ex) { Console.WriteLine($"An error occurred: {ex.Message}"); } return(artifactId); }
/// <summary> /// Agent logic goes here /// </summary> public override void Execute() { IAPILog logger = Helper.GetLoggerFactory().GetLogger(); try { //Get a dbContext for the workspace database int workspaceArtifactId = Helpers.Constants.WORKSPACE_ID; //Setting up an RSAPI Client using (IRSAPIClient rsapiClient = Helper.GetServicesManager().CreateProxy <IRSAPIClient>(ExecutionIdentity.CurrentUser)) { //Set the proxy to use the current workspace rsapiClient.APIOptions.WorkspaceID = workspaceArtifactId; var counter = 0; while (counter < 10) { var imageRDO = new RDO(); imageRDO.ArtifactTypeGuids.Add(Helpers.Constants.IMAGE_OBJECT_GUID); imageRDO.Fields.Add(new FieldValue(Helpers.Constants.IMAGE_NAME_FIELD_GUID, DateTime.Now.ToLongTimeString() + " " + counter.ToString())); rsapiClient.Repositories.RDO.Create(imageRDO); counter++; } } logger.LogVerbose("Log information throughout execution."); } catch (Exception ex) { //Your Agent caught an exception logger.LogError(ex, "There was an exception."); RaiseError(ex.Message, ex.Message); } }
protected List <RDO> GetRdos <T>(Condition queryCondition = null) where T : BaseDto { Query <RDO> query = new Query <RDO>() { ArtifactTypeGuid = BaseDto.GetObjectTypeGuid <T>(), Condition = queryCondition }; query.Fields = FieldValue.AllFields; QueryResultSet <RDO> results; using (IRSAPIClient proxyToWorkspace = CreateProxy()) { try { results = invokeWithRetryService.InvokeWithRetry(() => proxyToWorkspace.Repositories.RDO.Query(query)); } catch (Exception ex) { throw new ProxyOperationFailedException("Failed in method: " + System.Reflection.MethodInfo.GetCurrentMethod(), ex); } } if (results.Success == false) { throw new ArgumentException(results.Message); } return(results.Results.Select <Result <RDO>, RDO>(result => result.Artifact as RDO).ToList()); }
public Version GetCurrentApplicationVersion(int workspaceArtifactId, Guid applicationGuid) { try { using (IRSAPIClient rsapiClient = GetRsapiClient()) { rsapiClient.APIOptions.WorkspaceID = workspaceArtifactId; RelativityApplication relativityApplication; try { relativityApplication = rsapiClient.Repositories.RelativityApplication.ReadSingle(applicationGuid); } catch (Exception ex) { throw new Exception($"{Constants.ErrorMessages.QueryApplicationVersionError}. ReadSingle.", ex); } Version relativityApplicationVersion = new Version(relativityApplication.Version); return(relativityApplicationVersion); } } catch (Exception ex) { throw new Exception(Constants.ErrorMessages.QueryApplicationVersionError, ex); } }
public SearchHelper(IKeywordSearchManager keywordSearchManager, IdtSearchManager dtSearchManager, IDtSearchIndexManager dtSearchIndexManager, IRSAPIClient rsapiClient) { KeywordSearchManager = keywordSearchManager; DtSearchManager = dtSearchManager; DtSearchIndexManager = dtSearchIndexManager; RsapiClient = rsapiClient; }
public void InstallApplication(int workspaceArtifactId, FileInfo rapFilePath) { try { using (IRSAPIClient rsapiClient = GetRsapiClient()) { rsapiClient.APIOptions.WorkspaceID = workspaceArtifactId; List <int> appsToOverride = new List <int>(); const bool forceFlag = true; AppInstallRequest appInstallRequest = new AppInstallRequest(appsToOverride, forceFlag) { FullFilePath = rapFilePath.FullName }; appsToOverride.Add(1043043); //todo: testing try { rsapiClient.InstallApplication(rsapiClient.APIOptions, appInstallRequest); } catch (Exception ex) { throw new Exception($"{Constants.ErrorMessages.InstallApplicationError}. InstallApplication.", ex); } } } catch (Exception ex) { throw new Exception(Constants.ErrorMessages.InstallApplicationError, ex); } }
public static int Create_Group(IRSAPIClient client, String name) { var clientID = client.APIOptions.WorkspaceID; client.APIOptions.WorkspaceID = -1; Group newGroup = new Group(); newGroup.Name = name; WriteResultSet <kCura.Relativity.Client.DTOs.Group> resultSet = new WriteResultSet <Group>(); try { resultSet = client.Repositories.Group.Create(newGroup); if (!resultSet.Success || resultSet.Results.Count == 0) { throw new Exception("Group was not found"); } } catch (Exception e) { Console.WriteLine("Exception occured while trying to create a new group" + e); } var groupartid = resultSet.Results[0].Artifact.ArtifactID; client.APIOptions.WorkspaceID = clientID; return(groupartid); }
/// <summary> /// Retrieves User info by email /// </summary> /// <param name="email"></param> /// <returns></returns> private DTOs.User GetUser(string email) { DTOs.User user; Condition userQueryCondition = new TextCondition(UserFieldNames.EmailAddress, TextConditionEnum.EqualTo, email); Query <DTOs.User> userQuery = new Query <DTOs.User>(FieldValue.AllFields, userQueryCondition, new List <Sort>()); QueryResultSet <DTOs.User> resultSet = null; using (IRSAPIClient rsapiClient = GetServiceFactory().CreateProxy <IRSAPIClient>()) { rsapiClient.APIOptions = new APIOptions { WorkspaceID = -1 }; resultSet = rsapiClient.Repositories.User.Query(userQuery); if (resultSet.Success && resultSet.TotalCount > 0) { user = resultSet.Results.First().Artifact; } else { throw new Exception($"Could not find user {email}"); } } return(user); }
/// <summary> /// Will retrieve the data as a string from the YAML file to be parsed later /// </summary> /// <param name="serviceManager"></param> /// <param name="yamlFileArtifactID"></param> /// <param name="authToken"></param> /// <returns></returns> private async Task <string> DownloadYamlData(IServicesMgr serviceManager, int yamlFileArtifactID, string authToken) { string yamlData = ""; using (IRSAPIClient rsapiClient = serviceManager.CreateProxy <IRSAPIClient>(ExecutionIdentity.System)) { var domain = rsapiClient.EndpointUri.Host; var urlWIthoutProtocol = String.Format(Constants.URLs.ResourceFileDownload, domain, yamlFileArtifactID, authToken); try { //https vs http var yamlFileUrl = ((HttpContext.Current.Request.IsSecureConnection) ? Constants.Protocols.Https : Constants.Protocols.Http) + urlWIthoutProtocol; yamlData = await DownloadYamlFileAsync(new Uri(yamlFileUrl)); } catch (Exception ex) { _logHelper.LogError(ex, $"DAPI - {nameof(DownloadYamlData)} - Error attempting to download Yaml file: {ex}"); } } return(yamlData); }
/// <summary> /// Adds the user to the DynamicAPI Group for permissions /// </summary> /// <param name="groupId"></param> private void AddAdminUserToGroup(int groupId) { using (IRSAPIClient rsapiClient = GetServiceFactory().CreateProxy <IRSAPIClient>()) { DTOs.User user = GetUser(_userName); user.Groups.Add(new Group(groupId)); WriteResultSet <DTOs.User> userUpdateResults = null; try { userUpdateResults = rsapiClient.Repositories.User.Update(user); if (userUpdateResults.Success) { Console.WriteLine($"Added user to DynamicAPI Group"); } else { Console.WriteLine($"Unable to add user to DynamicAPI Group: {userUpdateResults.Message}"); } } catch (Exception ex) { Console.WriteLine($"An error occurred updating the user: {ex.Message}"); } } }
static bool?VerifyEmptyTarget(IRSAPIClient client) { // build the query / condition DTOs.Query <DTOs.Folder> query = new DTOs.Query <DTOs.Folder>(); // query for the folders DTOs.QueryResultSet <DTOs.Folder> resultSet = new DTOs.QueryResultSet <DTOs.Folder>(); try { resultSet = client.Repositories.Folder.Query(query, 0); } catch (Exception ex) { Console.WriteLine(String.Format("Exception:\r\n{0}\r\n{1}", ex.Message, ex.InnerException)); return(null); } // check for success if (resultSet.Success) { if (resultSet.Results.Count == 1) { return(true); } else { return(false); } } else { Console.WriteLine("Query was not successful."); return(null); } }
public static RDO RetrieveJob(IServicesMgr servicesMgr, int workspaceArtifactId, int jobArtifactId) { RDO jobRdo; try { using (IRSAPIClient rsapiClient = servicesMgr.CreateProxy <IRSAPIClient>(ExecutionIdentity.System)) { rsapiClient.APIOptions.WorkspaceID = workspaceArtifactId; try { jobRdo = rsapiClient.Repositories.RDO.ReadSingle(jobArtifactId); } catch (Exception ex) { throw new Exception($"{Constants.ErrorMessages.RETRIEVE_APPLICATION_JOB_ERROR}. ReadSingle. [{nameof(workspaceArtifactId)}= {workspaceArtifactId}, {nameof(jobArtifactId)}= {jobArtifactId}]", ex); } } } catch (Exception ex) { throw new Exception(Constants.ErrorMessages.RETRIEVE_APPLICATION_JOB_ERROR, ex); } return(jobRdo); }