/// <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> /// 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> /// 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> /// AUTHOR: Ashok Kolwal /// COMPANY: VITRANA /// Version: 1.0 /// Description: The IDfSysObject.getContent() command lets you get the contents of a document as a ByteArrayInputStream /// Last Modified date: 11 Jul,2017 /// </summary> /// <param name="sessionManager"></param> /// <param name="repositoryName"></param> /// <param name="objectIdString"></param> /// <returns></returns> public bool GetContent(IDfSessionManager sessionManager, String repositoryName, String objectIdString, String outputFolderPath) { IDfSession mySession = null; bool result = false; 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='" + objectIdString + "'"); // Instantiate an object from the ID. IDfSysObject sysObj = (IDfSysObject)mySession.getObject(idObj); // This is file output path plus file name. string fileFullPath = string.Concat(outputFolderPath, "\\", sysObj.getObjectName(), ".", sysObj.getContentType()); java.io.ByteArrayInputStream inputByteStrm = sysObj.getContent(); java.io.InputStream inputStrm = inputByteStrm; java.io.OutputStream outputStrm = new java.io.FileOutputStream(fileFullPath); // Transfer bytes from in to out byte[] byteArry = new byte[30720]; int len = 0; while ((len = inputStrm.read(byteArry)) > 0) { outputStrm.write(byteArry, 0, len); } inputStrm.close(); outputStrm.close(); result = true; // Console.WriteLine("Document has been exported with Name: " + Path.GetFileName(fileFullPath)); } // Handle any exceptions. catch (Exception ex) { // Console.WriteLine(ex.Message); throw new Exception("[GetContent] Error: " + ex.Message, ex); } // Always, always, release the session in the "finally" clause. finally { sessionManager.release(mySession); } return(result); }
/// <summary> /// AUTHOR: Ashok Kolwal /// COMPANY: VITRANA /// Version: 1.0 /// Description: You can use the IDfSystemObject.destroyAllVersions() method to permanently remove an object from the database. /// If you use the IDfPersistentObject.destroy() method, you will destroy only the specific system object /// corresponding to the r_object_id your provide. In this example, we use the destroyAllVersions()method, /// which destroys not only the system object with the correspondingID but all iterations of the object. /// If you attempt to destroy a directory that has children,the method will return an error. /// Last Modified date: 11 Jul,2017 /// </summary> /// <param name="sessionManager"></param> /// <param name="repositoryName"></param> /// <param name="objectIdString"></param> /// <returns></returns> public Boolean DestroyObject(IDfSessionManager sessionManager, String repositoryName, String objectIdString) { IDfSession mySession = null; try { mySession = sessionManager.getSession(repositoryName); IDfId idObj = mySession.getIdByQualification("dm_sysobject where r_object_id='" + objectIdString + "'"); IDfSysObject sysObj = (IDfSysObject)mySession.getObject(idObj); sysObj.destroyAllVersions(); // Console.WriteLine("Object has been deleted successfully"); return(true); } catch (Exception ex) { Console.WriteLine("Error while Deleting object : " + ex.Message + "\n StackTrace: " + ex.StackTrace); return(false); } finally { sessionManager.release(mySession); } }