/// <summary> /// Initializes the broker. /// </summary> /// <exception cref="Exception">Failed creating Documentum client</exception> private void InitializeBroker() { //File.AppendAllText("DqlConnect.log", sessionId + " InitalizeBroker\r\n\r\n"); _clientx = new DfClientX(); _client = _clientx.getLocalClient(); if (_client == null) { throw new Exception("Failed creating Documentum client"); } IDfTypedObject config = _client.getClientConfig(); builder = new DqlConnectionStringBuilder(this.ConnectionString); config.setString("dfc.docbroker.host", DefaultBrokerHost ?? SetDefaultBrokerHost()); //File.AppendAllText("DqlConnect.log", sessionId + " Broker set to: " + DefaultBrokerHost + Environment.NewLine); builder.SetExtendedProperties(config); //builder.GetExtendedProperties().ForEach(item => //{ config.setString(item.Key, item.Value); }); IDfDocbaseMap map = _client.getDocbaseMap(); Catalogs = new List <string>(); int count = map.getDocbaseCount(); for (int i = 0; i < count; i++) { Catalogs.Add(map.getDocbaseName(i)); } map = null; config = null; }
/// <summary> /// AUTHOR: Ashok Kolwal /// COMPANY: VITRANA /// Version: 1.0 /// Description: The execute method of an IDfMoveOperation object moves the current versions of documents or folders from one /// repository location to an other by unlinking them from the source location and linking them to the destination. /// Versions other than the current version remain linked to the original location. /// Last Modified date: 11 Jul,2017 /// </summary> /// <param name="mySession"></param> /// <param name="docId"></param> /// <param name="destination"></param> /// <returns></returns> public String MoveObject(IDfSession mySession, String docId, String destination) { try { IDfId idObj = mySession.getIdByQualification("dm_sysobject where r_object_id='" + docId + "'"); // Create a new client instance. IDfClientX clientx = new DfClientX(); // Use the factory method to create an IDfCopyOperation instance. IDfMoveOperation mo = clientx.getMoveOperation(); // Create an instance for the destination directory. IDfFolder destinationDirectory = mySession.getFolderByPath(destination); // Set the destination directory by ID. mo.setDestinationFolderId(destinationDirectory.getObjectId()); // Create a document object that represents the document being copied. IDfDocument doc = (IDfDocument)mySession.getObject(idObj); // Create a move node, adding the document to the move operation object. IDfMoveNode node = (IDfMoveNode)mo.add(doc); // Execute and return results if (mo.execute()) { return("Move operation successful."); } else { return("Move operation failed."); } } catch (Exception ex) { Console.WriteLine("Error while moving object : " + ex.Message + "\n StackTrace: " + ex.StackTrace); return(null); } }
/// <summary> /// Closes the connection to the database. This is the preferred method of closing any open connection. /// </summary> public override void Close() { _session = null; _loginInfoObj = null; _clientx = null; _client = null; state = ConnectionState.Closed; }
/// <summary> /// AUTHOR: Ashok Kolwal /// COMPANY: VITRANA /// Version: 1.0 /// Description: The execute method of an IDfCopyOperation object copies the current versions of documents /// or folders from one repository location to another. /// Last Modified date: 11 Jul,2017 /// </summary> /// <param name="sessionManager"></param> /// <param name="repositoryName"></param> /// <param name="docId"></param> /// <param name="destination"></param> /// <returns></returns> public String CopyDocument(IDfSessionManager sessionManager, String repositoryName, String docId, String destination) { IDfSession mySession = null; StringBuilder sb = new StringBuilder(""); try { mySession = sessionManager.getSession(repositoryName); // Get the object ID based on the object ID string. IDfId idObj = mySession.getIdByQualification("dm_sysobject where r_object_id='" + docId + "'"); // Instantiate an object from the ID. IDfSysObject sysObj = (IDfSysObject)mySession.getObject(idObj); // Create a new client instance. IDfClientX clientx = new DfClientX(); // Use the factory method to create an IDfCopyOperation instance. IDfCopyOperation co = clientx.getCopyOperation(); // Remove the path separator if it exists. if (destination.LastIndexOf("/") == destination.Length - 1 || destination.LastIndexOf("\\") == destination.Length - 1) { destination = destination.Substring(0, destination.Length - 1); } // Create an instance for the destination directory. IDfFolder destinationDirectory = mySession.getFolderByPath(destination); // Set the destination directory by ID. co.setDestinationFolderId(destinationDirectory.getObjectId()); // Create a document object that represents the document being copied. //IDfDocument doc = (IDfDocument)mySession.getObject(new DfId(docId)); IDfDocument doc = (IDfDocument)mySession.getObject(idObj); // Create a copy node, adding the document to the copy operation object. IDfCopyNode node = (IDfCopyNode)co.add(doc); // Execute and return results if (co.execute()) { return("Copy operation successful."); } else { return("Copy operation failed."); } } // Handle any exceptions. catch (Exception ex) { Console.WriteLine("Error while copying object : " + ex.Message + "\n StackTrace: " + ex.StackTrace); return("Exception has been thrown: " + ex); } // Always, always, release the session in the "finally" clause. finally { sessionManager.release(mySession); } }
/// <summary> /// AUTHOR: Ashok Kolwal /// COMPANY: VITRANA /// Version: 1.0 /// Description: The execute method of an IDfCheckoutOperation object checks out the documents in the operation. /// The checkout operation: /// • Locks the document /// • Copies the document to your local disk /// • Always creates registry entries to enable DFC to manage the files it creates on the file system /// Last Modified date: 11 Jul,2017 /// </summary> /// <param name="sessionManager"></param> /// <param name="repositoryName"></param> /// <param name="docId"></param> /// <returns></returns> public String Checkout(IDfSessionManager sessionManager, String repositoryName, String docId) { StringBuilder result = new StringBuilder(""); IDfSession mySession = null; try { mySession = sessionManager.getSession(repositoryName); // Get the object ID based on the object ID string. IDfId idObj = mySession.getIdByQualification("dm_sysobject where r_object_id='" + docId + "'"); // Instantiate an object from the ID. IDfSysObject sysObj = (IDfSysObject)mySession.getObject(idObj); // Instantiate a client. IDfClientX clientx = new DfClientX(); // Use the factory method to create a checkout operation object. IDfCheckoutOperation coOp = clientx.getCheckoutOperation(); // Set the location where the local copy of the checked out file // is stored. coOp.setDestinationDirectory("C:\\"); // Get the document instance using the document ID. IDfDocument doc = (IDfDocument)mySession.getObject(idObj); // Create the checkout node by adding the document to the checkout // operation. IDfCheckoutNode coNode = (IDfCheckoutNode)coOp.add(doc); // Verify that the node exists. if (coNode == null) { result.Append("coNode is null"); } // Execute the checkout operation. Return the result. if (coOp.execute()) { result.Append("Successfully checked out file ID: " + docId); } else { result.Append("Checkout failed."); } return(result.ToString()); } catch (Exception ex) { Console.WriteLine("Error while checkout : " + ex.Message + "\n StackTrace: " + ex.StackTrace); return("Exception hs been thrown: " + ex); } finally { sessionManager.release(mySession); } }
/// <summary> /// Sets the default broker host. /// </summary> /// <returns>System.String.</returns> public static string SetDefaultBrokerHost() { var clientx = new DfClientX(); var client = clientx.getLocalClient(); IDfTypedObject config = client.getClientConfig(); DefaultBrokerHost = config.getString("dfc.docbroker.host"); config = null; clientx = null; GC.Collect(); //FreeDllsNow(0); return(DefaultBrokerHost); }
/// <summary> /// AUTHOR: Ashok Kolwal /// COMPANY: VITRANA /// Version: 1.0 /// Description: The execute method of an IDfDeleteOperation object removes documents and folders from the repository. /// Last Modified date: 11 Jul,2017 /// </summary> /// <param name="sessionManager"></param> /// <param name="repositoryName"></param> /// <param name="docId"></param> /// <param name="versionNo"></param> /// <returns></returns> public String DeleteDocument(IDfSessionManager sessionManager, String repositoryName, String docId, int versionNo) { IDfSession mySession = null; try { mySession = sessionManager.getSession(repositoryName); // Get the object ID based on the object ID string. IDfId idObj = mySession.getIdByQualification("dm_sysobject where r_object_id='" + docId + "'"); // Instantiate an object from the ID. IDfSysObject sysObj = (IDfSysObject)mySession.getObject(idObj); // Create a new client instance. IDfClientX clientx = new DfClientX(); // Use the factory method to create an IDfDeleteOperation instance. IDfDeleteOperation delo = clientx.getDeleteOperation(); // Create a document object that represents the document being copied. //IDfDocument doc = (IDfDocument)mySession.getObject(new DfId(docId)); IDfDocument doc = (IDfDocument)mySession.getObject(idObj); // Set the deletion policy. You must do this prior to adding nodes to the // Delete operation. delo.setVersionDeletionPolicy(versionNo); // Create a delete node using the factory method. IDfDeleteNode node = (IDfDeleteNode)delo.add(doc); if (node == null) { return("Node is null."); } // Execute the delete operation and return results. if (delo.execute()) { return("Delete operation succeeded."); } else { return("Delete operation failed"); } } // Handle any exceptions. catch (Exception ex) { Console.WriteLine("Error while Deleting document : " + ex.Message + "\n StackTrace: " + ex.StackTrace); return("Exception has been thrown: " + ex); } // Always, always, release the session in the "finally" clause. finally { sessionManager.release(mySession); } }
/// <summary> /// AUTHOR: Ashok Kolwal /// COMPANY: VITRANA /// Version: 1.0 /// Description: The execute method of an IDfCancelCheckoutOperation object cancels the checkout of documents by releasing locks, /// deleting local files if appropriate,and removing registry entries. If the operation’s add method receives a virtual /// document as an argument, it also adds all of the document’sdescendants(determined by applying the applicable binding rules), /// creating a separate operation node for each. /// Last Modified date: 11 Jul,2017 /// </summary> /// <param name="sessionManager"></param> /// <param name="repositoryName"></param> /// <param name="docId"></param> /// <returns></returns> public String CancelCheckOut(IDfSessionManager sessionManager, String repositoryName, String docId) { IDfSession mySession = null; try { mySession = sessionManager.getSession(repositoryName); // Get the object ID based on the object ID string. IDfId idObj = mySession.getIdByQualification("dm_sysobject where r_object_id='" + docId + "'"); // Instantiate an object from the ID. IDfSysObject sysObj = (IDfSysObject)mySession.getObject(idObj); // Get a new client instance. IDfClientX clientx = new DfClientX(); // Use the factory method to create a checkout operation object. IDfCancelCheckoutOperation cco = clientx.getCancelCheckoutOperation(); // Instantiate the document object from the ID string. IDfDocument doc = (IDfDocument)mySession.getObject(idObj); // Indicate whether to keep the local file. cco.setKeepLocalFile(true); // Create an empty cancel checkout node. IDfCancelCheckoutNode node; // Populate the cancel checkout node and add it to the cancel checkout // operation. node = (IDfCancelCheckoutNode)cco.add(doc); // Check to see if the node is null - this will not throw an error. if (node == null) { return("Node is null"); } // Execute the operation and return the result. if (!cco.execute()) { return("Operation failed"); } return("Successfully cancelled checkout of file ID: " + docId); } // Handle any exceptions. catch (Exception ex) { Console.WriteLine("Error while cancelCheckOut object : " + ex.Message + "\n StackTrace: " + ex.StackTrace); return("Exception has been thrown: " + ex); } // Always, always, release the session in the "finally" clause. finally { sessionManager.release(mySession); } }
/// <summary> /// AUTHOR: Ashok Kolwal /// COMPANY: VITRANA /// Version: 1.0 /// Description: The execute method of an IDfCheckinOperation object checks documents into the repository. /// It creates new objects as required, transfers the content to the repository, /// and removes local files if appropriate. It checks in existing objects that any of the nodes /// refer to(forexample, throughXML links). /// Last Modified date: 11 Jul,2017 /// </summary> /// <param name="sessionManager"></param> /// <param name="repositoryName"></param> /// <param name="docId"></param> /// <returns></returns> public String Checkin(IDfSessionManager sessionManager, String repositoryName, String docId) { IDfSession mySession = null; try { mySession = sessionManager.getSession(repositoryName); // Get the object ID based on the object ID string. IDfId idObj = mySession.getIdByQualification("dm_sysobject where r_object_id='" + docId + "'"); // Instantiate an object from the ID. IDfSysObject sysObj = (IDfSysObject)mySession.getObject(idObj); // Instantiate a client. IDfClientX clientx = new DfClientX(); // Use the factory method to create an IDfCheckinOperation instance. IDfCheckinOperation cio = clientx.getCheckinOperation(); // Set the version increment. In this case, the next major version // ( version + 1) cio.setCheckinVersion(cio.getCheckinVersion() + 1); // When updating to the next major version, you need to explicitly // set the version label for the new object to "CURRENT". cio.setVersionLabels("CURRENT"); // Create a document object that represents the document being // checked in. IDfDocument doc = (IDfDocument)mySession.getObject(idObj); // Create a checkin node, adding it to the checkin operation. IDfCheckinNode node = (IDfCheckinNode)cio.add(doc); // Execute the checkin operation and return the result. if (!cio.execute()) { return("Checkin failed."); } // After the item is created, you can get it immediately using the // getNewObjectId method. IDfId newId = node.getNewObjectId(); return("Checkin succeeded - new object ID is: " + newId); } catch (Exception ex) { Console.WriteLine("Error while checkin object : " + ex.Message + "\n StackTrace: " + ex.StackTrace); return("Checkin failed."); } finally { sessionManager.release(mySession); } }
/// <summary> /// Releases the unmanaged resources used by the <see cref="T:System.ComponentModel.Component" /> and optionally releases the managed resources. /// </summary> /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param> protected override void Dispose(bool disposing) { //File.AppendAllText("DqlConnect.log", sessionId + " Dispose\r\n"); base.Dispose(disposing); if (disposing) { this._client = null; this._clientx = null; this._session = null; this._loginInfoObj = null; state = ConnectionState.Closed; // FreeDllsNow(0); GC.Collect(); // GC.WaitForPendingFinalizers(); } }
/// <summary> /// AUTHOR: Ashok Kolwal /// COMPANY: VITRANA /// Version: 1.0 /// Description: This method is used for get the session variable based on documentum server info. /// Last Modified date: 11 Jul,2017 /// </summary> /// <param name="sessionVariableObject"></param> /// <returns></returns> public object GetSessionManager(GetSessionEntity sessionVariableObject) { object sessionVariable = null; try { IDfClientX clientX = new DfClientX(); // Console.WriteLine("[GetSessionManager] IDfClientX instance created"); IDfClient client = clientX.getLocalClient(); // Console.WriteLine("[GetSessionManager] IDfClient instance created"); IDfSessionManager sMgr = client.newSessionManager(); // Console.WriteLine("[GetSessionManager] IDfSessionManager instance created"); IDfLoginInfo loginInfo = clientX.getLoginInfo(); // Console.WriteLine("[GetSessionManager] IDfLoginInfo instance created"); loginInfo.setUser(sessionVariableObject.UserName); loginInfo.setPassword(sessionVariableObject.Password); loginInfo.setDomain(""); sMgr.setIdentity(sessionVariableObject.RepositoryName, loginInfo); // Console.WriteLine("[GetSessionManager] LoginInfo identity is set"); IDfSession session = sMgr.getSession(sessionVariableObject.RepositoryName); // Console.WriteLine("[GetSessionManager] IDfSession instance created"); switch (sessionVariableObject.SessionVariableType) { case IDFSessionVariableType.IDfSession: sessionVariable = session; break; case IDFSessionVariableType.IDfSessionManager: sessionVariable = sMgr; break; } ; } catch (Exception ex) { throw new Exception("Error in [GetSessionManager] ", ex); } return(sessionVariable); }