OLDER ARTICLES

CSharp/C# : Get the source folder path of CSharp class

20
Nov

posted by Huseyin OZVEREN filed under C#, DEVELOPMENT

Hi,

Here, an example to get the source folder path of CSharp class via a static method and the package System.Runtime.CompilerServices. In fact, we solicit the compiler in order to get some informations about caller (caller line number, caller method, caller file path): https://msdn.microsoft.com/fr-fr/library/system.runtime.compilerservices.callermembernameattribute(v=vs.110).aspx.

using System.IO;
using System.Runtime.CompilerServices;

namespace HuoBlog
{
    public class ModelUtility
    {
        public static string getProjectPath([CallerMemberName] string memberName = "",
                [CallerFilePath] string sourceFilePath = "",
                [CallerLineNumber] int sourceLineNumber = 0)
        {
            // new System.Diagnostics.StackTrace(true).GetFrame(0).GetFileName();
            string currentClassPath = getInternalPath();
            string currentProjectPath = Path.GetDirectoryName(currentClassPath);
            return currentProjectPath;
        }


        private static string getInternalPath([CallerMemberName] string memberName = "",
                [CallerFilePath] string sourceFilePath = "",
                [CallerLineNumber] int sourceLineNumber = 0)
        {
            return sourceFilePath;
        }
    }
}

…in the caller method, for example a simple Program.cs, some parameters Callerxxxx are set by compiler:

//...
string currentModelProjectPath = ModelUtility.getProjectPath();
//...

//...
// [CallerMemberName] string memberName = "Main"
// [CallerFilePath] string sourceFilePath = "C:\\Workspaces\\MS_Visual_Studio_Projects\\...\\Program.cs"
// [CallerLineNumber] int sourceLineNumber = 38

        public static string getProjectPath([CallerMemberName] string memberName = "",
                [CallerFilePath] string sourceFilePath = "",
                [CallerLineNumber] int sourceLineNumber = 0)
        {
                //...
        }
//...

//...
// [CallerMemberName] string memberName = "getProjectPath"
// [CallerFilePath] string sourceFilePath = "C:\\Workspaces\\MS_Visual_Studio_Projects\\...\\ModelUtility.cs"
// [CallerLineNumber] int sourceLineNumber = 13

        private static string getInternalPath([CallerMemberName] string memberName = "",
                [CallerFilePath] string sourceFilePath = "",
                [CallerLineNumber] int sourceLineNumber = 0)
        {
                //...
        }
//...

That’s all!!!!

Huseyin OZVEREN

Tags: C#, Class, CSharp, Get, path

Comments (0)

CSharp/C# : Generate Custom Types from XSD file, XmlSerializer, XML Validation

20
Nov

posted by Huseyin OZVEREN filed under C#, DEVELOPMENT

Hi,

A post with concrete examples concerning the generation of Types/POJO from a XSD file, the serialization of these objects/POJO to XML and finally the validation of XML with XSD.

Generate Custom Types from XSD file

XSD file myXsdFile.xsd:

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
            targetNamespace="urn:books"
            xmlns:bks="urn:books">

  <xsd:element name="books" type="bks:BooksForm"/>

  <xsd:complexType name="BooksForm">
    <xsd:sequence>
      <xsd:element name="book"
                  type="bks:BookForm"
                  minOccurs="0"
                  maxOccurs="unbounded"/>
    </xsd:sequence>
  </xsd:complexType>

  <xsd:complexType name="BookForm">
    <xsd:sequence>
      <xsd:element name="author"   type="xsd:string"/>
      <xsd:element name="title"    type="xsd:string"/>
      <xsd:element name="genre"    type="xsd:string"/>
      <xsd:element name="price"    type="xsd:float" />
      <xsd:element name="pub_date" type="xsd:date" />
      <xsd:element name="review"   type="xsd:string"/>
    </xsd:sequence>
    <xsd:attribute name="id"   type="xsd:string"/>
  </xsd:complexType>
</xsd:schema>

CSharp sources and types generator:

        /// <summary>
        /// Custom Types Generator from XSD file
        /// </summary>
        /// <param name="xsdFile"></param>
        /// <param name="outputFile"></param>
        private static bool generateCSharpFile(string xsdFile, string outputFile)
        {
            bool result = true;
            try
            {
                var stream = new MemoryStream(File.ReadAllBytes(xsdFile));

                var schema = XmlSchema.Read(XmlReader.Create(stream), null);
                var schemas = new XmlSchemas();
                schemas.Add(schema);

                var ns = new CodeNamespace { Name = "books" };
                ns.Imports.Add(new CodeNamespaceImport("System"));
                ns.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));

                var exporter = new XmlCodeExporter(ns);
                var importer = new XmlSchemaImporter(schemas);

                foreach (XmlSchemaElement element in schema.Elements.Values)
                {
                    var mapping = importer.ImportTypeMapping(element.QualifiedName);
                    exporter.ExportTypeMapping(mapping);
                }

                // Transform CodeDOM as required, adding new attributes, methods, modifying
                // inheritance hierarchy, whatever.
                var provider = new CSharpCodeProvider();

                using (var writer = new StreamWriter(outputFile, false))
                {
                    // Creates a new CodeGeneratorOptions.
                    CodeGeneratorOptions genOptions = new CodeGeneratorOptions();

                    // Sets a value indicating that the code generator should insert blank lines between type members.
                    genOptions.BlankLinesBetweenMembers = true;

                    // Sets the style of bracing format to use: either "Block" to start a
                    // bracing block on the same line as the declaration of its container, or 
                    // "C" to start the bracing for the block on the following line.
                    genOptions.BracingStyle = "C";

                    // Sets a value indicating that the code generator should not append an else, 
                    // catch or finally block, including brackets, at the closing line of a preceeding if or try block.
                    genOptions.ElseOnClosing = false;

                    // Sets the string to indent each line with.
                    genOptions.IndentString = "    ";

                    // Uses the CodeGeneratorOptions indexer property to set an
                    // example object to the type's string-keyed ListDictionary.
                    // Custom ICodeGenerator implementations can use objects 
                    // in this dictionary to customize process behavior.
                    genOptions["CustomGeneratorOptionStringExampleID"] = "BuildFlags: /A /B /C /D /E";

                    provider.GenerateCodeFromNamespace(ns, writer, genOptions);
                }
            }
            catch (Exception ex)
            {
                Console.Write(ex.ToString());
                result = false;
            }

            return result;
        }

//….

            string xsdFile = "C:\\Workspaces\\MS_Visual_Studio_Projects\\TestApps\\TestXmlXsd1\\myXsdFile.xsd";
            string outputFile = "C:\\Workspaces\\MS_Visual_Studio_Projects\\TestApps\\TestXmlXsd1\\generated\\MyCustomTypes.cs";

            generateCSharpFile(xsdFile, outputFile);

After execution, a CSharp file MyCustomTypes.cs containing all types of XSD file is generated:

namespace books
{
    using System;
    using System.Collections.Generic;
    
    
    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("TestXmlXsd1", "1.0.0.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="urn:books")]
    [System.Xml.Serialization.XmlRootAttribute("books", Namespace="urn:books", IsNullable=false)]
    public partial class BooksForm
    {
        
        private BookForm[] bookField;
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute("book", Form=System.Xml.Schema.XmlSchemaForm.Unqualified)]
        public BookForm[] book
        {
            get
            {
                return this.bookField;
            }
            set
            {
                this.bookField = value;
            }
        }
    }
    
    /// <remarks/>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("TestXmlXsd1", "1.0.0.0")]
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace="urn:books")]
    public partial class BookForm
    {
        
        private string authorField;
        
        private string titleField;
        
        private string genreField;
        
        private float priceField;
        
        private System.DateTime pub_dateField;
        
        private string reviewField;
        
        private string idField;
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified)]
        public string author
        {
            get
            {
                return this.authorField;
            }
            set
            {
                this.authorField = value;
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified)]
        public string title
        {
            get
            {
                return this.titleField;
            }
            set
            {
                this.titleField = value;
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified)]
        public string genre
        {
            get
            {
                return this.genreField;
            }
            set
            {
                this.genreField = value;
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified)]
        public float price
        {
            get
            {
                return this.priceField;
            }
            set
            {
                this.priceField = value;
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified, DataType="date")]
        public System.DateTime pub_date
        {
            get
            {
                return this.pub_dateField;
            }
            set
            {
                this.pub_dateField = value;
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified)]
        public string review
        {
            get
            {
                return this.reviewField;
            }
            set
            {
                this.reviewField = value;
            }
        }
        
        /// <remarks/>
        [System.Xml.Serialization.XmlAttributeAttribute()]
        public string id
        {
            get
            {
                return this.idField;
            }
            set
            {
                this.idField = value;
            }
        }
    }
}

Serialization of objects to XML

Instantiation of POJO objects and use of them in order to generate XML file myXmlFile.xml:

        /// <summary>
        /// Generate XML file for POJO annotated (System.Xml)
        /// </summary>
        /// <param name="model"></param>
        /// <param name="xmlFile"></param>
        private static bool generateXML(object model, string xmlFile)
        {
            bool result = true;
            try
            {
                // Build POJO
                var serializer = new XmlSerializer(model.GetType());

                using (StreamWriter writer = new StreamWriter(xmlFile, true, new UTF8Encoding(false)))
                {
                    serializer.Serialize(writer, model);
                }
            }
            catch (XmlSchemaValidationException ex)
            {
                Console.Write(ex.ToString());
                result = false;
            }

            return result;
        }

//….

            string xmlGeneratedFile = "C:\\Workspaces\\MS_Visual_Studio_Projects\\TestApps\\TestXmlXsd1\\myXmlFile.xml";
            BooksForm booksForm = new BooksForm();
            {
                List<BookForm> booksList = new List<BookForm>();
                {
                    BookForm book = new BookForm();
                    book.id = "bk001";
                    book.author = "Writer";
                    book.title = "The First Book";
                    book.genre = "Fiction";
                    book.price = 44.95F;
                    book.pub_date = DateTime.ParseExact("2000-10-01", "yyyy-MM-dd", CultureInfo.InvariantCulture);
                    book.review = "An amazing story of nothing.";
                    booksList.Add(book);
                }
                {
                    BookForm book = new BookForm();
                    book.id = "bk002";
                    book.author = "Poet";
                    book.title = "The Poet's First Poem";
                    book.genre = "Poem";
                    book.price = 24.95F;
                    book.review = "Least poetic poems.";
                    booksList.Add(book);
                }
                booksForm.book = booksList.ToArray();
            }


            generateXML(booksForm, xmlGeneratedFile);

The generated XML file myXmlFile.xml would be:

<?xml version="1.0" encoding="utf-8"?>
<books xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="urn:books">
  <book id="bk001" xmlns="">
    <author>Writer</author>
    <title>The First Book</title>
    <genre>Fiction</genre>
    <price>44.95</price>
    <pub_date>2000-10-01</pub_date>
    <review>An amazing story of nothing.</review>
  </book>
  <book id="bk002" xmlns="">
    <author>Poet</author>
    <title>The Poet's First Poem</title>
    <genre>Poem</genre>
    <price>24.95</price>
    <pub_date>0001-01-01</pub_date>
    <review>Least poetic poems.</review>
  </book>
</books>

Validation of XML with XSD file

Validation of generated XML myXmlFile.xml with original XSD file myXsdFile.xml:

        /// <summary>
        /// Validate XML file with XSD file
        /// </summary>
        /// <param name="xmlFilePath"></param>
        /// <param name="xsdFilePath"></param>
        /// <param name="namespaceName"></param>
        /// <returns></returns>
        private static bool IsValidXml(string xmlFilePath, string xsdFilePath, string namespaceName)
        {
            var xdoc = XDocument.Load(xmlFilePath);
            var schemas = new XmlSchemaSet();
            schemas.Add(namespaceName, xsdFilePath);

            bool result = true;
            try
            {
                xdoc.Validate(schemas, (sender, e) =>
                {
                    Console.Write("Error:" + e.Message);
                    result = false;
                });
            }
            catch (XmlSchemaValidationException ex)
            {
                Console.Write(ex.ToString());
                result = false;
            }
            return result;
        }

//….

            string xsdFile = "C:\\Workspaces\\MS_Visual_Studio_Projects\\TestApps\\TestXmlXsd1\\myXsdFile.xsd";
            string xmlGeneratedFile = "C:\\Workspaces\\MS_Visual_Studio_Projects\\TestApps\\TestXmlXsd1\\myXmlFile.xml";

            IsValidXml(xmlGeneratedFile, xsdFile, "urn:books");

Note: Below the import / using needed to these methods:

using Microsoft.CSharp;
using System;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.IO;
using System.Xml;
using System.Xml.Linq;
using System.Xml.Schema;
using System.Xml.Serialization;
using System.Text;
using books;
using System.Collections.Generic;
using System.Globalization;

Best regards,

Huseyin OZVEREN

Tags: C#, Custom, generation, Type, Types, Validation, xml, XmlSerializer, XSD

Comments (0)

Documentum : Creation of DFS Web Service

11
Nov

posted by Huseyin OZVEREN filed under DEVELOPMENT, Documentum, Java, Libray, Tools

Hi,

I would like to describe step by step how to create a DFS service and DFS client via Composer. In this post, I am not exposing neither the deployment of this DFS service on an application server, neither the configuration of DFC file on server allowing the access to Documentum Content Server.

First, what is DFS?
EMC Documentum Foundation Services (DFS) are a set of technologies that enable service-oriented programmatic access to the EMC Documentum Content Server platform and related products. […] The design and technical implementation of DFS is grounded in the principles of Service-Oriented Architecture (SOA).

The DFS Software Development Kit (SDK) includes Java class libraries, .NET assemblies, tools, documentation, and samples that you can use to build DFS services that extend the delivered DFS services, or to build DFS consumers using the optional C# or Java client library.

DFS Service Creation

Create a Documentum Project:
DFS Libraries
When an Documentum Project is created it also adds all the necessary DFS resources to allow you to develop Documentum services. It will deploy a copy of the DFS SDK to your core project (incidentally this is why creating the first project in a workspace takes a little longer than you might expect) and add the DFS Services Library to your project’s java build path. And add a DFS Builder for building your services.

Click on the Documentum Project and bring up its DFS Module properties:

…then select Builders, you should see DFS builder:

…then select the Java Build Path, then the Libraries tab you will see DFS Service Library:

Some words concerning the DFS Library, If you select DFS Services Library and click on Edit… button:

…OR if you click on Add Library…:

As you can see there are 4 types of DFS Services Library:
o DFS Services Library: it is the default library used in order to developing services.
o DFS Remote Client Library with UCF/MTOM: Theses libraries are used in order to developing services consumers.
o DFS Local Client Library: This library is also used in order to developing services consumers, however, this type of library is added to projects that are acting as “functional tests” for your services projects. Typically, you create one or more of these “functional test” projects in the same workspace as your services projects and configure them with this type of library. This then allows you to debug from the client into the service and back again without having to deploy to a server. A useful feature.

Building a Service
See : EMC Documentum Documentum Foundation Services Development Guide Version 6.5. : https://www.emc.com/collateral/TechnicalDocument/docu7122.pdf

There are a couple of types of DFS service; based on a POJO OR based on a BOF SBO (service-based object). They are, in fact, very similar and are just annotated java classes.

o Create the com.java.lu.business.ecm.business package in the folder Web Services/src:

o Create the text properties file JavaLuECMService.properties:

o Create the com.java.lu.business.service.ecm.business.exception package in the folder Web Services/src:

o Create the exception class JavaLuECMServiceException.java:

package com.java.lu.business.service.ecm.business.exception;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlType;

import com.emc.documentum.fs.rt.ServiceException;
import com.java.lu.business.service.ecm.business.JavaLuECMService;

@XmlType(name = "JavaLuECMServiceException", namespace = "http://exception.business.ecm.service.business.lu.java.com/")
@XmlAccessorType(XmlAccessType.FIELD)
public class JavaLuECMServiceException extends ServiceException {

	private static final long serialVersionUID = -8678484668814217250L + JavaLuECMService.buildNumber;

	public JavaLuECMServiceException() {
		super();
	}

	public JavaLuECMServiceException(String errorCode, Throwable cause) {
		super(errorCode, cause);
	}

	public JavaLuECMServiceException(Throwable cause) {
		super(cause);
	}
}

o Create a folder ant containing the properties file dfs-build.properties:

# EMC DFS SDK 6.0 build properties template
#dfs.sdk.home=../..
#dfs.sdk.home=C:/Temp/dfs/sdk
#projectdir=C:/Temp/DocumentumProject

# Compiler options
compiler.debug=on
compiler.generate.no.warnings=off
compiler.args=
compiler.max.memory=128m
fork = true
nonjava.pattern = **/*.java,**/.svn,**/_svn

# Establish the production and tests build folders
#build.folder = build
module.name=module-name
context.root=context-root

#Debug information
debug=true
keep=true
verbose=true
extension=true

application.version=1
release.version=3

tracing.enabled=true
mode.debug=true

o Create a the XML file dfs-build.xml:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<project name="EMC DFS SDK 6.5 build script (Ant) template" default="info">

	<property file="${basedir}/dfs-build.properties" />
	<property file="${basedir}/dfs-autodeploy.properties" />

	<!-- mandatory properties -->
	<fail unless="dfs.sdk.home" message="DFS SDK HOME (dfs.sdk.home) not set" />

	<!-- optional properties, default values are set here -->
	<property name="project.resources.folder" value="${gen.rsc}" />
	<property name="project.gen.build.folder" value="${gen.build}" />
	<property name="dfs.sdk.libs" value="${dfs.sdk.home}/lib/java" />
	<property name="dfs.sdk.etc" value="${dfs.sdk.home}/etc" />
	<taskdef file="${dfs.sdk.libs}/emc-dfs-tasks.xml" />
	<!-- Depending projects -->
	<property name="project.TestDfsWs.folder" value="${basedir}/../../TestDfsWs" />

	<!-- private propertes -->
	<property name="project" value="DFS Build (Services + Remote Client)" />

	<fileset id="dfs.classpath" dir="${dfs.sdk.home}/lib">
		<include name="emc-dfs-rt.jar" />
		<include name="emc-dfs-tools.jar" />
		<include name="emc-dfs-services.jar" />
	</fileset>

	<fileset id="jaxws.classpath" dir="${dfs.sdk.libs}/jaxws">
		<include name="activation.jar" />
		<include name="FastInfoset.jar" />
		<include name="http.jar" />
		<include name="jaxb-api.jar" />
		<include name="jaxb-impl.jar" />
		<include name="jaxb-xjc.jar" />
		<include name="jaxws-api.jar" />
		<include name="jaxws-rt.jar" />
		<include name="jaxws-tools.jar" />
		<include name="jsr173_api.jar" />
		<include name="jsr181-api.jar" />
		<include name="jsr250-api.jar" />
		<include name="resolver.jar" />
		<include name="saaj-api.jar" />
		<include name="saaj-impl.jar" />
		<include name="sjsxp.jar" />
		<include name="stax-ex.jar" />
		<include name="streambuffer.jar" />
	</fileset>

	<fileset id="dfc.classpath" dir="${dfs.sdk.libs}">
		<include name="dfc/dfc.jar" />
		<!-- Keep the following path element list in sync with dfc.jar manifest (i.e. internal manifest.mf file: -->
		<include name="ucf/client/All-MB.jar" />
		<include name="jaxws/activation.jar" />
		<include name="utils/aspectjrt.jar" />
		<include name="dfc/certjFIPS.jar" />
		<include name="dfc/dms-client-api.jar" />
		<include name="jaxws/jaxb-api.jar" />
		<include name="jaxws/jaxb-impl.jar" />
		<include name="dfc/jsafeFIPS.jar" />
		<include name="jaxws/jsr173_api.jar" />
		<include name="utils/log4j.jar" />
		<include name="utils/serializer.jar" />
		<include name="utils/xalan.jar" />
		<include name="utils/xercesImpl.jar" />
		<include name="utils/xml-apis.jar" />
		<include name="utils/xtrim-api.jar" />
		<include name="utils/xtrim-server.jar" />
		<!-- Additional library for Workflow service: -->
		<include name="dfc/bpm_infra.jar" />
	</fileset>

	<fileset id="ucf.client.classpath" dir="${dfs.sdk.libs}/ucf/client">
		<include name="*.jar" />
	</fileset>

	<fileset id="ucf.client.all.files" dir="${dfs.sdk.libs}/ucf/client" />

	<fileset id="ucf.installer.classpath" dir="${dfs.sdk.libs}/ucf/client">
		<include name="ucf-installer.jar" />
	</fileset>

	<fileset id="ucf.server.classpath" dir="${dfs.sdk.libs}/ucf/server">
		<include name="*.jar" />
	</fileset>

	<fileset id="apache.common.classpath" dir="${dfs.sdk.libs}/commons">
		<include name="*.jar" />
	</fileset>

	<fileset id="utils.classpath" dir="${dfs.sdk.libs}/utils">
		<include name="*.jar" />
	</fileset>
	<fileset id="extjars.classpath" dir="${dfs.sdk.libs}">
		<include name="extjars/*.jar" />
	</fileset>
	<path id="project.classpath">
		<fileset refid="dfs.classpath" />
		<fileset refid="jaxws.classpath" />
		<fileset refid="dfc.classpath" />
		<fileset refid="ucf.server.classpath" />
		<fileset refid="ucf.client.classpath" />
		<fileset refid="apache.common.classpath" />
		<fileset refid="utils.classpath" />
		<fileset refid="extjars.classpath" />
		<path location="${project.resources.folder}" />
		<path location="${dfs.sdk.etc}" />
	</path>

	<property name="defaultclasspath" refid="project.classpath" />
	<echo message="defaultclasspath is ${defaultclasspath}" />

	<condition property="projectclasspath" value="${defaultclasspath}">
		<not>
			<isset property="projectclasspath" />
		</not>
	</condition>

	<echo message="projectclasspath is ${projectclasspath}" />

	<path id="projectclasspath.path">
		<pathelement path="${projectclasspath}" />
	</path>

	<path id="default_project_libraries.path" location="" />
	<property name="default_project_libraries" refid="default_project_libraries.path" />
	<echo message="default_project_libraries is ${default_project_libraries}" />

	<condition property="project_libraries" value="${default_project_libraries}">
		<not>
			<isset property="project_libraries" />
		</not>
	</condition>

	<path id="project_libraries.path">
		<pathelement path="${project_libraries}" />
	</path>

	<property name="project_libraries.path.echo" refid="project_libraries.path" />
	<echo message="project_libraries.path is ${project_libraries.path.echo}" />

	<path id="default_project_resources.path" location="" />
	<property name="default_project_resources" refid="default_project_resources.path" />
	<echo message="default_project_resources is ${default_project_resources}" />

	<condition property="project_resources" value="${default_project_resources}">
		<not>
			<isset property="project_resources" />
		</not>
	</condition>

	<path id="project_resources.path">
		<pathelement path="${project_resources}" />
	</path>

	<property name="project_resources.path.echo" refid="project_resources.path" />
	<echo message="project_resources.path is ${project_resources.path.echo}" />

	<target name="clean">
		<echo message="Clean the ${project}" />

		<delete failonerror="false" includeemptydirs="true">
			<fileset dir="${gen.src.dir}/" includes="**/*" />
		</delete>

		<delete failonerror="false" includeemptydirs="true">
			<fileset dir="${project.resources.folder}/" includes="**/*" />
		</delete>

		<delete failonerror="false" includeemptydirs="true">
			<fileset dir="${project.gen.build.folder}/" includes="**/*" />
		</delete>
		<delete>
			<fileset dir="${dfs.sdk.libs}/extjars" includes="**/*.jar" />
		</delete>
	</target>

	<target name="package">
		<echo message="Package the ${project}" />

		<move todir="${project.resources.folder}">
			<fileset dir="${gen.src.dir}/" includes="wsdl/, *.xml" />
		</move>

		<mkdir dir="${project.gen.build.folder}/" />

		<buildService serviceName="${module.name}" destDir="${project.gen.build.folder}" generatedArtifactsDir="${project.resources.folder}">
			<src>
				<path location="${src.dir}" />
				<path location="${gen.src.dir}/" />
			</src>

			<classpath>
				<path refid="projectclasspath.path" />
				<path>
					<fileset refid="extjars.classpath" />
				</path>
			</classpath>
		</buildService>

		<packageService deploymentName="${module.name}" destDir="${project.gen.build.folder}" generatedArtifactsDir="${project.resources.folder}">
			<libraries>
				<path refid="project_libraries.path" />
				<pathelement location="${project.gen.build.folder}/${module.name}.jar" />
				<pathelement location="${dfs.sdk.libs}/extjars/*.jar" />
				<pathelement location="${dfs.sdk.libs}/bof/bpm_infra.jar" />
				<pathelement location="${dfs.sdk.libs}/bof/ci.jar" />
				<pathelement location="${dfs.sdk.libs}/bof/collaboration.jar" />
				<pathelement location="${dfs.sdk.libs}/bof/extended-search-api.jar" />
				<pathelement location="${dfs.sdk.libs}/bof/workflow.jar" />
				<pathelement location="${dfs.sdk.libs}/dfc/certjFIPS.jar" />
				<pathelement location="${dfs.sdk.libs}/dfc/configservice-api.jar" />
				<pathelement location="${dfs.sdk.libs}/dfc/configservice-impl.jar" />
				<pathelement location="${dfs.sdk.libs}/dfc/dfc.jar" />
				<pathelement location="${dfs.sdk.libs}/dfc/dms-client-api.jar" />
				<pathelement location="${dfs.sdk.libs}/dfc/jsafeFIPS.jar" />
				<pathelement location="${dfs.sdk.libs}/dfc/xtrim-api.jar" />
				<pathelement location="${dfs.sdk.libs}/dfc/xtrim-server.jar" />
				<pathelement location="${dfs.sdk.libs}/ucf/client/All-MB.jar" />
				<pathelement location="${dfs.sdk.libs}/utils/aspectjrt.jar" />
				<pathelement location="${dfs.sdk.libs}/emc-bpm-services.jar" />
				<pathelement location="${dfs.sdk.libs}/emc-ci-services.jar" />
				<pathelement location="${dfs.sdk.libs}/emc-collaboration-services.jar" />
				<pathelement location="${dfs.sdk.libs}/emc-dfs-services.jar" />
				<pathelement location="${dfs.sdk.libs}/emc-search-services.jar" />
			</libraries>
			<resources>
				<path refid="project_resources.path" />
			</resources>
		</packageService>
	</target>

	<target name="export" depends="package">
		<delete>
			<fileset dir="${export.dir}">
				<include name="*.*" />
			</fileset>
		</delete>
		<move todir="${export.dir}">
			<fileset dir="${project.gen.build.folder}" includes="*.ear, *-remote.jar" />
		</move>
		<property name="config-folder" value="${project.TestDfsWs.folder}/config" />
		<property name="ear.filename" value="${export.dir}/${module.name}.ear" />
		<!--delete file="${export.dir}/${module.name}-remote.jar" /-->
		<mkdir dir="${export.dir}/__tmp__" />
		<unzip dest="${export.dir}/__tmp__" src="${ear.filename}" />
		<delete file="${ear.filename}" />
		<move file="${export.dir}/__tmp__/lib" todir="${export.dir}/__tmp__/APP-INF" />
		<copy flatten="false" todir="${export.dir}/__tmp__/APP-INF/classes" overwrite="true">
			<fileset dir="${config-folder}/common">
				<include name="**/*" />
			</fileset>
			<fileset dir="${project.TestDfsWs.folder}/Web Services/src">
				<include name="**/*" />
				<exclude name="**/*.java" />
			</fileset>
		</copy>


		<delete>
			<fileset dir="${export.dir}/__tmp__/APP-INF/classes">
				<include name="dfc.properties" />
				<include name="log4j.properties" />
			</fileset>
		</delete>

		<buildnumber file="JavaLuECMService.buildnumber" />
		<property name="build.version" value="${application.version}.${release.version}.${build.number}" />
		
		<tstamp>
			<format property="build.time" pattern="dd/MM/yyyy HH:mm:ss" />
		</tstamp>
		
		<manifest file="${export.dir}/__tmp__/META-INF/MANIFEST.MF">
			<attribute name="Created-By" value="${user.name}" />
			<attribute name="Product-Name" value="JavaLuECMService for Documentum" />
			<attribute name="Product-Version" value="${application.version}" />
			<attribute name="Build-Version" value="${build.version}" />
			<attribute name="Build-Date" value="${build.time}" />
			<attribute name="Vendor-Name" value="PricewaterhouseCoopers Luxembourg (c)" />
			<attribute name="UseWSFEP61ScanPolicy" value="true" />
			<attribute name="UseEJB61FEPScanPolicy" value="true" />
		</manifest>
		
		<copy todir="${export.dir}/__tmp__/APP-INF/lib" overwrite="true" flatten="true">
			<fileset dir="${dfs.sdk.libs}">
				<include name="utils/krbutil.jar" />
				<include name="utils/jcifs-krb5-1.3.1.jar" />
				<include name="commons/commons-codec-1.3.jar" />
				<include name="commons/commons-lang-2.4.jar" />
			</fileset>
		</copy>
		<modifyDfsRuntime dfs-rt.jar="${export.dir}/__tmp__/APP-INF/lib/emc-dfs-rt.jar" />

		<fileset id="dist.contents" dir="${export.dir}/__tmp__" includes="*.war" />
		<property name="prop.dist.contents" refid="dist.contents" />

		<foreach list="${prop.dist.contents}" delimiter=";" param="foreach.file">
			<param name="jar.dir" value="${export.dir}/__tmp__/APP-INF/lib" />
			<param name="ear.tmp.dir" value="${export.dir}/__tmp__" />
		</foreach>
		<zip destfile="${ear.filename}" basedir="${export.dir}/__tmp__" />
		<delete dir="${export.dir}/__tmp__" />
		<tstamp>
			<format property="folder.time" pattern="yyyyMMddHHmmss" />
		</tstamp>
		<mkdir dir="${export.dir}/${folder.time}" />
		<property name="ear.filename.new" value="DOC${module.name}-${build.version}.ear" />
		<copy file="${ear.filename}" tofile="${export.dir}/${folder.time}/${ear.filename.new}" />
		<copy file="${export.dir}/${module.name}-remote.jar" todir="${export.dir}/${folder.time}" />
		<move file="${ear.filename}" tofile="${export.dir}/${ear.filename.new}" overwrite="true" />
		<move file="${export.dir}/${module.name}-remote.jar" todir="${export.dir}" />

	</target>

	<macrodef name="modifyDfsRuntime">
		<attribute name="dfs-rt.jar" />
		<sequential>
			<delete dir="${basedir}/___dfs-rt___" includeemptydirs="true" />
			<mkdir dir="${basedir}/___dfs-rt___" />
			<unzip dest="${basedir}/___dfs-rt___" src="@{dfs-rt.jar}" />
			<delete file="@{dfs-rt.jar}" />

			<propertyfile file="${basedir}/___dfs-rt___/dfs-runtime.properties">
				<entry key="tracing.enabled" value="${tracing.enabled}" />
				<entry key="mode.debug" value="${mode.debug}" />
				<entry key="service.ContentTransferMode" value="MTOM" />
				<entry key="dfs.query_cache_policy.query_max_result" value="1000" />
				<entry key="dfs.query_cache_policy.query_max_elements" value="1500" />
				<entry key="dfs.query_cache_policy.cache_delta" value="500" />
				<entry key="dfs.crs.cache_expiration_after_x_minutes" value="720" />
				<entry key="dfs.crs.perform_cleanup_every_x_minutes" value="20" />
			</propertyfile>

			<jar destfile="@{dfs-rt.jar}" basedir="${basedir}/___dfs-rt___" />
			<delete dir="${basedir}/___dfs-rt___" includeemptydirs="true" />
		</sequential>
	</macrodef>

	<target name="deploy">
		<echo message="Deploy the ${project}" />
		<copy file="${basedir}/build/${module.name}.ear" todir="${autodeploy.dir}" />
	</target>

	<target name="generate-service">
		<generateService wsdlUri="${wsdl.uri}" destDir="${dest.dir}" />
	</target>

	<target name="generate-decoupled-client">
		<generateRemoteClient wsdlUri="${wsdl.uri}" destDir="${dest.dir}" />
	</target>

	<target name="info">
		<echo message="Available tasks for ${project}" />
		<echo message="ant clean      - to clean the project" />
		<echo message="ant package    - to package the project" />
		<echo message="---- Optional tasks -------------------------------" />
		<echo message="ant generate   - to build JAX-WS specific artifacts" />
		<echo message="---------------------------------------------------" />
	</target>


</project>

o Create the file JavaLuECMService.buildnumber:

#Build Number for ANT. Do not edit!
#Wed Aug 16 16:06:16 CEST 2017
build.number=139

o Create the com.java.lu.business.service.ecm.business.result package in the folder Web Services/src:

o Create the result class BinaryContent.java:

package com.java.lu.business.service.ecm.business.result;

import java.io.Serializable;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;

@XmlType(name = "BinaryContent", namespace = "http://result.business.ecm.service.business.lu.java.com")
@XmlRootElement(name = "BinaryContent")
@XmlAccessorType(XmlAccessType.FIELD)
public class BinaryContent implements Serializable {
	private static final long serialVersionUID = 8693573608799806206L;
	@XmlElement(name = "data")
	private byte[] data;
	@XmlAttribute(name = "format")
	private String format;

	public BinaryContent() {
		this(null, null);
	}

	public BinaryContent(byte[] data, String format) {
		this.data = data;
		this.format = format;
	}

	public void setData(byte[] data) {
		this.data = data;
	}

	public byte[] getData() {
		return data;
	}

	public void setFormat(String format) {
		this.format = format;
	}

	public String getFormat() {
		return format;
	}

	@Override
	public String toString() {
		return new StringBuilder().append("<").append(getClass().getSimpleName()).append(" format='").append(getFormat()).append("'>").append("<data>").append(getData()).append("</data></").append(getClass().getSimpleName()).append(">").toString();
	}

	public final static String XLS_FORMAT = "excel8book";
	public final static String XLSX_FORMAT = "excel12book";
	public final static String PDF_FORMAT = "pdf";
}

o Create the result class DocumentInfo.java:

package com.java.lu.business.service.ecm.business.result;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;


@XmlType(name = "DocumentInfo", namespace = "http://result.business.ecm.service.business.lu.java.com")
@XmlRootElement(name = "DocumentInfo")
@XmlAccessorType(XmlAccessType.FIELD)
public class DocumentInfo implements Serializable {
	private static final long serialVersionUID = -8343058576424166034L;
	@XmlAttribute(name = "objectId")
	private String objectId;
	@XmlAttribute(name = "objectName")
	private String objectName;
	@XmlElement(name = "content")
	private BinaryContent content;
	@XmlElement(name = "errors")
	private List<ServiceError> errors;

	
	public DocumentInfo() {
	}

	public String getObjectName() {
		return objectName;
	}

	public void setObjectName(String objectName) {
		this.objectName = objectName;
	}

	public String getObjectId() {
		return objectId;
	}

	public void setObjectId(String objectId) {
		this.objectId = objectId;
	}

	public BinaryContent getContent() {
		return content;
	}

	public void setContent(BinaryContent content) {
		this.content = content;
	}

	public final List<ServiceError> getErrors() {
		if (errors == null)
			errors = new ArrayList<ServiceError>();
		return errors;
	}

	public final void setErrors(List<ServiceError> errors) {
		this.errors = errors;
	}

	public final void addError(ServiceError error) {
		this.errors.add(error);
	}

	public final void addErrors(List<ServiceError> errors) {
		this.errors.addAll(errors);
	}
	
	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append("<").append(getClass().getSimpleName());
		sb.append(" objectId='").append(objectId).append("'");
		sb.append(" objectName='").append(objectName).append("'");
		sb.append(">");
		if (content != null) {
			sb.append("<content>").append(content).append("</content>");
		}
		sb.append(super.toString());
		sb.append("</").append(getClass().getSimpleName()).append(">");
		return sb.toString();
	}
}

o Create the result error class ServiceError.java:

package com.java.lu.business.service.ecm.business.result;

import java.io.PrintWriter;
import java.io.Serializable;
import java.io.StringWriter;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;

@XmlType(name = "ServiceError", namespace = "http://result.business.ecm.service.business.lu.java.com")
@XmlRootElement(name = "ServiceError")
@XmlAccessorType(XmlAccessType.FIELD)
public class ServiceError implements Serializable {

	private static final long serialVersionUID = -2515772948068877071L;

	@XmlAttribute(name = "code")
	private int code;
	@XmlAttribute(name = "message")
	private String message;
	@XmlElement(name = "trace")
	private String trace;

	public final static int UNDEFINED = 0;

	private static String getStackTraceAsString(Throwable t) {
		String result = "";

		if (t != null) {
			StringWriter sw = new StringWriter();
			PrintWriter pw = new PrintWriter(sw);
			t.printStackTrace(pw);
			pw.flush();
			result = sw.toString();
		}

		return result;
	}

	public ServiceError() {
		this(UNDEFINED, null, null);
	}

	public ServiceError(int code, String message, String trace) {
		super();
		this.code = code;
		this.message = message;
		this.trace = trace;
	}

	public ServiceError(String message) {
		this(UNDEFINED, message, null);
	}

	public ServiceError(String message, Throwable trace) {
		this(UNDEFINED, message, getStackTraceAsString(trace));
	}

	public int getCode() {
		return code;
	}

	public String getMessage() {
		return message;
	}

	public String getTrace() {
		return trace;
	}

	public void setCode(int code) {
		this.code = code;
	}

	public void setMessage(String message) {
		this.message = message;
	}

	public void setTrace(String trace) {
		this.trace = trace;
	}

	public void setTrace(Throwable trace) {
		setTrace(getStackTraceAsString(trace));
	}

	@Override
	public String toString() {
		return new StringBuilder().append("<").append(getClass().getSimpleName()).append(" code='").append(getCode()).append("'").append(" message='").append(getMessage()).append("'>").append("<trace>").append(getTrace()).append("</trace>").append("</").append(getClass().getSimpleName()).append(">").toString();
	}
}

o Create the service class JavaLuECMService.java with a method getDocumentInfo returning a DocumentInfo POJO from a r_object_id of document:

package com.java.lu.business.service.ecm.business;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.Serializable;
import java.text.MessageFormat;
import java.util.Properties;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.io.IOUtils;
import org.apache.log4j.Logger;

import com.documentum.fc.client.DfClient;
import com.documentum.fc.client.IDfClient;
import com.documentum.fc.client.IDfDocument;
import com.documentum.fc.client.IDfSession;
import com.documentum.fc.client.IDfSessionManager;
import com.documentum.fc.common.DfException;
import com.documentum.fc.common.DfLoginInfo;
import com.documentum.fc.common.IDfLoginInfo;
import com.documentum.fc.common.impl.MessageHelper;
import com.emc.documentum.fs.datamodel.core.properties.NumberProperty;
import com.emc.documentum.fs.datamodel.core.properties.PropertySet;
import com.emc.documentum.fs.datamodel.core.properties.StringProperty;
import com.emc.documentum.fs.rt.AuthenticationException;
import com.emc.documentum.fs.rt.annotations.DfsPojoService;
import com.java.lu.business.service.ecm.business.exception.JavaLuECMServiceException;
import com.java.lu.business.service.ecm.business.result.BinaryContent;
import com.java.lu.business.service.ecm.business.result.DocumentInfo;
import com.java.lu.business.service.ecm.business.result.ServiceError;


@DfsPojoService(requiresAuthentication = false, targetNamespace = "http://business.ecm.service.business.lu.java.com", useDeprecatedExceptionModel = false)
public class JavaLuECMService implements Serializable {
	
	private final static Logger logger = Logger.getLogger(JavaLuECMService.class);
	private final static PropertySet versionProperties;
	private static final long serialVersionUID;
	public static final long buildNumber;
	
	static {
		try {
			versionProperties = new PropertySet();
			Properties properties = new Properties();
			InputStream inputStream = JavaLuECMService.class.getResourceAsStream(JavaLuECMService.class.getSimpleName() + ".properties");
			try {
				if(inputStream!=null){
					properties.load(inputStream);
					buildNumber = Long.parseLong(properties.getProperty("Build-Number"));
					serialVersionUID = 1768427593645267965L + buildNumber;
					for (java.util.Map.Entry<Object, Object> entry : properties.entrySet()) {
						versionProperties.set(new StringProperty(String.valueOf(entry.getKey()), String.valueOf(entry.getValue())));
					}
					versionProperties.set(new NumberProperty("serialVersionUID", serialVersionUID));
				}else{
					buildNumber = 1;
					serialVersionUID = 1768427593645267965L;
				}
			} finally {
				if(inputStream!=null){
					inputStream.close();
				}
			}
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}
	
	/**
	 * Returns various properties set at packaging time.
	 * 
	 * @return 
	 */
	public PropertySet getVersionProperties() {
		return versionProperties;
	}
	
	
	public DocumentInfo getDocumentInfo(String documentId) throws JavaLuECMServiceException, AuthenticationException {
		if (logger.isDebugEnabled()) {
			logger.debug(MessageFormat.format("getDocumentInfo(documentId={0}) - START", documentId));
		}
		DocumentInfo result;
		try {
			//String docbase = com.documentum.services.config.util.DocbaseUtils.getDocbaseNameFromId(documentId);
			//if (StringUtils.isBlank(docbase)) {
			//	throw new Exception(MessageFormat.format("Cannot determine repository from objectId {0}", documentId));
			//}
			String docbase = "MY_HUO_DOCBASE";			
			String user = "huoadm";
			String passwd = "password_4huoadm";
			
			IDfSession dfSession = getDfSession(user, passwd, docbase);
			try {
				result = new DocumentInfo();
				// IDfDocument dfDocument = (IDfDocument) dfSession.getObject(new DfId(documentId));
				IDfDocument dfDocument;
				{
					String qualification = getDocumentQualification(documentId);
					dfDocument = (IDfDocument) dfSession.getObjectByQualification(qualification);
					if (dfDocument == null) {
						throw new DfException("Unable to find document for user " + dfSession.getLoginUserName() + " with qualification " + qualification);
					}
				}

				// result.setObjectId(dfDocument.getObjectId().getId());
				result.setObjectId(dfDocument.getChronicleId().getId());
				result.setObjectName(dfDocument.getObjectName());
				ByteArrayInputStream input = dfDocument.getContent();
				try {
					ByteArrayOutputStream output = new ByteArrayOutputStream();
					try {
						IOUtils.copy(input, output);
						BinaryContent binaryContent = new BinaryContent();
						binaryContent.setData(output.toByteArray());
						binaryContent.setFormat(dfDocument.getContentType());
						result.setContent(binaryContent);
					} finally {
						IOUtils.closeQuietly(output);
					}
				} finally {
					IOUtils.closeQuietly(input);
				}
			} finally {
				releaseSession(dfSession);
			}
		} catch (Throwable e) {
			logger.fatal(e.getMessage(), e);
			result = new DocumentInfo();
			result.getErrors().add(new ServiceError(ServiceError.UNDEFINED, e.getMessage(), MessageHelper.getStackTraceAsString(e)));
		}
		return result;
	}	

	private IDfSession getDfSession(String user, String passwd, String docbase) throws Exception {
		IDfLoginInfo login = new DfLoginInfo();
		login.setUser(user);
		login.setPassword(passwd);
		IDfClient client = DfClient.getLocalClient(); // new DfClient();
		IDfSessionManager sessMgr = client.newSessionManager();
		sessMgr.setIdentity(docbase, login);
		IDfSession idfSession = sessMgr.getSession(docbase);
		if (idfSession != null)
			System.out.println("Session created successfully");

		return idfSession;
	}
	
	private void releaseSession(IDfSession dfSession) throws Exception {
		dfSession.getSessionManager().release(dfSession);
	}
	
	private String getDocumentQualification(String documentId) {
		Pattern pattern = Pattern.compile("^(([a-f0-9]{2})([a-f0-9]{6})([a-f0-9]{8}))$");
		Matcher matcher = pattern.matcher(documentId);
		if (!matcher.matches()) {
			throw new RuntimeException(documentId + " is not a valid objectId");
		}
		StringBuilder dql = new StringBuilder();
		dql.append(" dm_document WHERE r_object_id IN (");
		dql.append("  SELECT r_object_id");
		dql.append("  FROM my_huo_document");
		dql.append("  WHERE ").append("i_chronicle_id").append(" = ID('").append(matcher.group(1)).append("')");
		dql.append(")");
		;
		return dql.toString();
	}
	

}

o Assuming that you have automatic build turned on from project menu in composer, you should see the DFS Builder leap into life and attempt to build the service. In your Console view you’ll get a build report:

Buildfile: C:\Workspaces\DocumentumCoreProject\dfs6.7\dfs-build.xml
…

generate:
[generateModel] Creating 'myservices-mybusiness-service-model.xml'
[generateArtifacts] Log4j not found. In order to avoid error messages during build process, please include log4j.jar into your classpath or copy it into $ANT_HOME/lib folder
[generateArtifacts] Generating DFS artifacts
[generateArtifacts] Generating JAXWS artifacts (wsgen & wsimport)
[generateArtifacts] Note: C:\Users\HUSEYI~1\AppData\Local\Temp\dfs-sdk-3247901826753623178-server-artifacts-generator\wsimport\wsgen\generated\src\com\java\lu\business\service\ecm\business\ws\JavaLuECMServiceWebService.java uses unchecked or unsafe operations.
[generateArtifacts] Note: Recompile with -Xlint:unchecked for details.
[generateArtifacts] fdir.getAbsolutePath() = C:\Users\HUSEYI~1\AppData\Local\Temp\dfs-sdk-3247901826753623178-server-artifacts-generator\wsimport\wsgen\wsdl\com.java.lu.business.service.ecm.business.ws
[generateArtifacts] ------------------------------------------------------------
[generateArtifacts] SerializableExceptionPostProcessor.addSerializableException
[generateArtifacts] file = C:\Users\HUSEYI~1\AppData\Local\Temp\dfs-sdk-3247901826753623178-server-artifacts-generator\wsimport\src\com\java\lu\business\service\ecm\business\ws\JavaLuECMServicePort.java
[generateArtifacts] ------------------------------------------------------------
BUILD SUCCESSFUL
Total time: 22 seconds

o After building, the Web Services/bin/gen-src folder contains a set of generated sources from the POJO service : jax-ws web service sources, a set of classes and wsdl.

Export/Test the service

There are two approaches to test our service:

o The first approach is to create a parallel test project with Junit tests that exercise your service. To facilitate this your test project would be configured with the local client library, as described above, so that it can make local invocations to your service. This project should of course be placed under the same version control as your services project.

o The second approach is to export your services as an ear, deploy it to an application server and exercise your service again via another project capable of making remote service invocations. The service’s context root and module name affect the URL of service, these informations must be set via right-click on the project and select Properties->Documentum Project->DFS Module:

Here, we use the second approach:

o Right-click on the project and select Export…, then Documentum >> Export Service Archive to generate ear of service and client reference library:

o Select the output folder and uncheck the Generate Publish Manifest checkbox:

Tips: To avoid re-entering the destination directory each time, change the Export Directory setting in Preferences in COMPOSER:

o Click on Finish button to launch the generation:
```
Override ignored for property "TODAY"
    [mkdir] Created dir: C:\temp\dfs6.7sp2\20171109141738
     [copy] Copying 1 file to C:\temp\dfs6.7sp2\20171109141738
     [copy] Copying C:\temp\dfs6.7sp2\mybusiness.ear to C:\temp\dfs6.7sp2\20171109141738\DOCmybusiness-1.3.141.ear
     [copy] Copying 1 file to C:\temp\dfs6.7sp2\20171109141738
     [copy] Copying C:\temp\dfs6.7sp2\mybusiness-remote.jar to C:\temp\dfs6.7sp2\20171109141738\mybusiness-remote.jar
     [move] Moving 1 file to C:\temp\dfs6.7sp2
     [move] Attempting to rename: C:\temp\dfs6.7sp2\mybusiness.ear to C:\temp\dfs6.7sp2\DOCmybusiness-1.3.141.ear
     [move] Moving 1 file to C:\temp\dfs6.7sp2
     [move] Skipping self-move of C:\temp\dfs6.7sp2\mybusiness-remote.jar
BUILD SUCCESSFUL

BUILD SUCCESSFUL
Total time: 1 minute 4 seconds
```
This will produce:
o an ear file which can be deploy onto an application server (websphere, tomcat…) : mybusiness.ear
o a jar file containing the client classes : mybusiness-remote.jar

The output folder contains the ear file (service) and the jar (remote) and a subfolder “YYYYMMDDHHMISS” with the previous ear.

Note : The naming of ear file is configurable in dfs6.7 folder of DocumentumCoreProject project:
… dfs-build.xml:
```
<property name="ear.filename.new" value="DOC${module.name}-${build.version}.ear" />
<property name="build.version" value="${application.version}.${release.version}.${build.number}" />
```
… dfs-build.properties:
```
module.name=module-name
application.version=1
release.version=3
build.number=141
```

Deployment of EAR on Application Server
Once EAR file deployed, you can perform a quick sanity check by requesting the service’s WSDL document: http://localhost:9080/myservices/mybusiness/JavaLuECMService

The WSDL is available http://localhost:9080/myservices/mybusiness/JavaLuECMService?wsdl

This XML file does not appear to have any style information associated with it. The document tree is shown below.
<!--
 Published by JAX-WS RI at http://jax-ws.dev.java.net. RI's version is JAX-WS RI 2.1.7-b01-. 
-->
<definitions xmlns="http://schemas.xmlsoap.org/wsdl/" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tns="http://ws.business.ecm.service.business.lu.java.com/"xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="JavaLuECMService" targetNamespace="http://ws.business.ecm.service.business.lu.java.com/">
<types>
<xsd:schema>
<xsd:import namespace="http://ws.business.ecm.service.business.lu.java.com/" schemaLocation="http://localhost:9080/myservices/mybusiness/JavaLuECMService?xsd=1"/>
</xsd:schema>
<xsd:schema>
<xsd:import namespace="http://rt.fs.documentum.emc.com/" schemaLocation="http://localhost:9080/myservices/mybusiness/JavaLuECMService?xsd=2"/>
</xsd:schema>
<xsd:schema>
<xsd:import namespace="http://result.business.ecm.service.business.lu.java.com" schemaLocation="http://localhost:9080/myservices/mybusiness/JavaLuECMService?xsd=3"/>
</xsd:schema>
<xsd:schema>
<xsd:import namespace="http://properties.core.datamodel.fs.documentum.emc.com/" schemaLocation="http://localhost:9080/myservices/mybusiness/JavaLuECMService?xsd=4"/>
</xsd:schema>
<xsd:schema>
<xsd:import namespace="http://core.datamodel.fs.documentum.emc.com/" schemaLocation="http://localhost:9080/myservices/mybusiness/JavaLuECMService?xsd=5"/>
</xsd:schema>
<xsd:schema>
<xsd:import namespace="http://content.core.datamodel.fs.documentum.emc.com/" schemaLocation="http://localhost:9080/myservices/mybusiness/JavaLuECMService?xsd=6"/>
</xsd:schema>
</types>
<message name="getVersionProperties">
<part element="tns:getVersionProperties" name="parameters"/>
</message>
<message name="getVersionPropertiesResponse">
<part element="tns:getVersionPropertiesResponse" name="parameters"/>
</message>
<message name="ServiceException">
<part xmlns:ns1="http://rt.fs.documentum.emc.com/" element="ns1:ServiceException" name="fault"/>
</message>
<message name="getDocumentInfo">
<part element="tns:getDocumentInfo" name="parameters"/>
</message>
<message name="getDocumentInfoResponse">
<part element="tns:getDocumentInfoResponse" name="parameters"/>
</message>
<message name="AuthenticationException">
<part element="tns:AuthenticationException" name="fault"/>
</message>
<message name="JavaLuECMServiceException">
<part element="tns:JavaLuECMServiceException" name="fault"/>
</message>
<portType name="JavaLuECMServicePort">
<operation name="getVersionProperties">
<documentation>
Returns various properties set at packaging time. @return
</documentation>
<input message="tns:getVersionProperties"/>
<output message="tns:getVersionPropertiesResponse"/>
<fault message="tns:ServiceException" name="ServiceException"/>
</operation>
<operation name="getDocumentInfo">
<input message="tns:getDocumentInfo"/>
<output message="tns:getDocumentInfoResponse"/>
<fault message="tns:AuthenticationException" name="AuthenticationException"/>
<fault message="tns:JavaLuECMServiceException" name="JavaLuECMServiceException"/>
<fault message="tns:ServiceException" name="ServiceException"/>
</operation>
</portType>
<binding name="JavaLuECMServicePortBinding" type="tns:JavaLuECMServicePort">
<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
<operation name="getVersionProperties">
<soap:operation soapAction=""/>
<input>
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
</output>
<fault name="ServiceException">
<soap:fault name="ServiceException" use="literal"/>
</fault>
</operation>
<operation name="getDocumentInfo">
<soap:operation soapAction=""/>
<input>
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
</output>
<fault name="AuthenticationException">
<soap:fault name="AuthenticationException" use="literal"/>
</fault>
<fault name="JavaLuECMServiceException">
<soap:fault name="JavaLuECMServiceException" use="literal"/>
</fault>
<fault name="ServiceException">
<soap:fault name="ServiceException" use="literal"/>
</fault>
</operation>
</binding>
<service name="JavaLuECMService">
<port binding="tns:JavaLuECMServicePortBinding" name="JavaLuECMServicePort">
<soap:address location="http://localhost:9080/myservices/mybusiness/JavaLuECMService"/>
</port>
</service>
</definitions>

DFS Service Client Creation

Create a Documentum Project:
Change the default DFS Services Library to DFS Local Client Library:
Add the jar xxxx-remote.jar previously generated in the Java Build Path of Client project:
Create a new package com.java.lu.test in the folder src / com.java.lu.test:

Create a class JavaLuECMServiceClient:

package com.java.lu.test;

import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;

import javax.xml.bind.JAXBContext;
import javax.xml.namespace.QName;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.soap.SOAPEnvelope;
import javax.xml.soap.SOAPFactory;
import javax.xml.soap.SOAPHeader;
import javax.xml.ws.handler.Handler;
import javax.xml.ws.handler.HandlerResolver;
import javax.xml.ws.handler.MessageContext;
import javax.xml.ws.handler.PortInfo;
import javax.xml.ws.handler.soap.SOAPHandler;
import javax.xml.ws.handler.soap.SOAPMessageContext;

import org.w3c.dom.Document;
import org.w3c.dom.Element;

import com.emc.documentum.fs.datamodel.core.context.BasicIdentity;
import com.emc.documentum.fs.datamodel.core.context.ServiceContext;
import com.java.lu.business.service.ecm.business.result.DocumentInfo;
import com.java.lu.business.service.ecm.business.ws.JavaLuECMService;
import com.java.lu.business.service.ecm.business.ws.JavaLuECMServicePort;
import com.sun.xml.internal.bind.api.JAXBRIContext;

public class JavaLuECMServiceClient {

	public static void main(String[] args) {
		try {
			final JavaLuECMServicePort service = registerToDocumentum("http://localhost:9080/myservices/mybusiness/JavaLuECMService?wsdl", "huoadm", " password_4huoadm");
			DocumentInfo documentInfo = service.getDocumentInfo("0902xxxxxxe14");
			System.out.println(documentInfo.getObjectId());
			System.out.println(documentInfo.getObjectName());
			System.out.println(documentInfo.getContent().getFormat());
			System.out.println(documentInfo.getContent().getData().length);

		} catch (Throwable e) {
			e.printStackTrace();
		}
	}

	private static JavaLuECMServicePort registerToDocumentum(String urlWS, String user, String pwd) {
		try {
			ServiceContext serviceContext = new ServiceContext();
			BasicIdentity basicIdentity = new BasicIdentity();
			basicIdentity.setUserName(user);
			basicIdentity.setPassword(pwd);
			serviceContext.getIdentities().add(basicIdentity);
			JAXBContext j = JAXBRIContext.newInstance(ServiceContext.class);
			Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
			j.createMarshaller().marshal(serviceContext, document);
			final Element wsseSecurity = document.getDocumentElement();
			
			JavaLuECMService yourWebService = new JavaLuECMService(new URL(urlWS), new QName("http://ws.business.ecm.service.business.lu.java.com/", "JavaLuECMService"));
			yourWebService.setHandlerResolver(new HandlerResolver() {
				public List<Handler> getHandlerChain(PortInfo portInfo) {
					List<Handler> handlerList = new ArrayList<Handler>();
					handlerList.add(new SOAPHandler<SOAPMessageContext>() {
						public void close(MessageContext context) {
						}

						public Set<QName> getHeaders() {
							return new TreeSet<QName>();
						}

						public boolean handleFault(SOAPMessageContext context) {
							throw new UnsupportedOperationException("Not supported yet.");
						}

						public boolean handleMessage(SOAPMessageContext context) {
							Boolean outboundProperty = (Boolean) context.get(MessageContext.MESSAGE_OUTBOUND_PROPERTY);
							if (outboundProperty.booleanValue()) {
								try {
									SOAPEnvelope envelope = context.getMessage().getSOAPPart().getEnvelope();
									SOAPHeader header = envelope.addHeader();
									header.addChildElement(SOAPFactory.newInstance().createElement(wsseSecurity));
								} catch (Exception e) {
									System.out.println("Exception in handler: " + e);
								}
							} else {
								// inbound
							}
							return true;
						}
					});
					return handlerList;
				}
			});
			return yourWebService.getJavaLuECMServicePort();

		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}	
}

Execute this client class:

0902xxxxxxe14
My doc name
excel12book
8739

It’s also possible to return EMC objects : DataPackage, Content …

Example 1 : DataPackage

	/**
	 * Return com.emc.documentum.fs.datamodel.core.DataPackage
	 * com.emc.documentum.fs.datamodel.core.DataPackage
	 * 		+ dataObjects : ArrayList<DataObject>
	 * 		+ repositoryName : String
	 * 
	 */
	public DataPackage getDocument(String rObjectId) {
		DataPackage retDataPackage = null;
		try {
			String repositoryName = "MY_HUO_DOCBASE";         
			//String user = "huoadm";
			//String passwd = "password_4huoadm";
			
			StringBuilder dql = new StringBuilder();
			dql.append(" SELECT r_object_id, ");
			dql.append(" object_name, ");
			dql.append(" r_creator_name, ");
			dql.append(" r_creation_date ");
			dql.append(" FROM my_huo_document doc ");
			dql.append(" WHERE r_object_id = '");
			dql.append(rObjectId);
			dql.append("'");

			QueryExecution queryExecution = new QueryExecution(0, -1);
			OperationOptions options = new OperationOptions();
			IQueryService queryService = getQueryService(ContextFactory.getInstance().getContext(), true, repositoryName);
			QueryResult queryResult = queryService.execute(new PassthroughQuery(Collections.singletonList(repositoryName), dql.toString()), queryExecution, options);

			retDataPackage = queryResult.getDataPackage();
			
		} catch (Throwable th) {
			String message = MessageFormat.format("getDocument({0}) failed", rObjectId);
			dfsLogger.error(message, th);
		}
		return retDataPackage;
	}

Example 2 : Content

	/**
	 * Return com.emc.documentum.fs.datamodel.core.content.Content
	 */
	public Content getContentAsBinary(String objectId) {
		return getContent(objectId, com.emc.documentum.fs.datamodel.core.profiles.UrlReturnPolicy.NEVER);
	}

	
	/**
	 * Return com.emc.documentum.fs.datamodel.core.content.UrlContent  
	 * 
	 * http://myDctmServer:9080/ACS/servlet/ACS?command=read
	 * 		&version=2.3
	 * 		&docbaseid=022XXX
	 * 		&basepath=%5C%5CLUFIL012%5Cdata%5CMY_DOCBASE_DEV%5Ccontent_storage_01%5C00022XXX
	 * 		&filepath=myfile.pdf
	 * 		&objectid=09022XXXXXXXX255
	 * 		&cacheid=dAAEAXXXXXXXXXXXXXXXXD%3D
	 * 		&format=pdf
	 * 		&pagenum=0
	 * 		&signature=MIgbxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxjokIA%3D
	 * 		&servername=myDctmServerACS1
	 * 		&mode=1
	 * 		&timestamp=1528269518
	 * 		&length=151443
	 * 		&mime_type=application%2Fpdf
	 * 		&parallel_streaming=true
	 * 		&expire_delta=360
	 */
	public Content getContentAsURL(String objectId) {
		return getContent(objectId, com.emc.documentum.fs.datamodel.core.profiles.UrlReturnPolicy.ALWAYS);
	}
	
	private Content getContent(String objectId, com.emc.documentum.fs.datamodel.core.profiles.UrlReturnPolicy urlReturnPolicy) {
		Content retContent = null;
		try {
			String repositoryName = "MY_HUO_DOCBASE";         
			//String user = "huoadm";
			//String passwd = "password_4huoadm";
			IObjectService objectService = getObjectService(ContextFactory.getInstance().getContext(), true, repositoryName);

			OperationOptions options = new OperationOptions();
			PropertyProfile propertyProfile = new PropertyProfile(PropertyFilterMode.NONE);
			options.setProfile(propertyProfile);
			ContentProfile contentProfile = new ContentProfile();
			contentProfile.setUrlReturnPolicy(urlReturnPolicy);
			contentProfile.setFormatFilter(FormatFilter.ANY);
			contentProfile.setPageFilter(PageFilter.ANY);
			contentProfile.setPageModifierFilter(PageModifierFilter.ANY);
			contentProfile.setRenditionOption(RenditionOption.PRIMARY);
			options.setProfile(contentProfile);

			if (urlReturnPolicy.equals(UrlReturnPolicy.NEVER)) {
				ContentTransferProfile contentTransferProfile = new ContentTransferProfile();
				contentTransferProfile.setTransferMode(ContentTransferMode.MTOM);
				options.setProfile(contentTransferProfile);

			}
			StringBuilder dql = new StringBuilder();
			dql.append("my_huo_document (ALL) WHERE r_object_id = ID('").append(StringUtils.replace(objectId, "'", "''")).append("')");

			ObjectIdentity<Qualification<String>> objectIdentity = new ObjectIdentity<Qualification<String>>(new Qualification<String>(dql.toString()), repositoryName);
			
			if(objectIdentity==null){
				throw new RuntimeException("Document not found with ID='"+objectId+"' ");
			}
			
			DataPackage dataPackage = objectService.get(new ObjectIdentitySet(objectIdentity), options);
			if (dataPackage!=null && dataPackage.getDataObjects()!=null && dataPackage.getDataObjects().size() > 0) {
				DataObject dataObject = dataPackage.getDataObjects().get(0);
				if (dataObject.getContents().size() > 0) {
					Content content = dataObject.getContents().get(0);
					if (urlReturnPolicy.equals(UrlReturnPolicy.NEVER)) {
						retContent = getDataHandlerContent(content);
					} else {
						retContent = content;
					}
				} else {
					throw new RuntimeException("Unable to retrieve content from DataObject with ID='"+objectId+"' and identity " + dataObject.getIdentity() + " ");
				}
			} else {
				throw new RuntimeException("Unable to find DataObject with ID='"+objectId+"' and identity " + objectIdentity + " ");
			}
			
		} catch (Throwable th) {
			String message = MessageFormat.format("getContent({0},{1}) failed", objectId, urlReturnPolicy);
			dfsLogger.error(message, th);
		}
		return retContent;
	}

Example 3 : Upload

	public String uploadDocument(String objectName, int companyId, final int personId, Content content) {
		String objectId;
		try {
			String repositoryName = "MY_HUO_DOCBASE";  
			String user = "huoadm";
			String passwd = "password_4huoadm";
			
			IDfSession dfSession = getDfSession(user, passwd, repositoryName);
			try {
				boolean transaction = false;
				boolean noError = false;
				try {
					if (!dfSession.isTransactionActive()) {
						dfSession.beginTrans();
						transaction = true;
					}
					IDfDocument document = (IDfDocument) dfSession.newObject("my_huo_document");

					// Returns an integer number that corresponds to the access permission level that the current user has for the object.
					// DF_PERMIT_NONE = 1 / DF_PERMIT_BROWSE = 2 / DF_PERMIT_READ = 3 / DF_PERMIT_RELATE = 4 / DF_PERMIT_VERSION = 5 / DF_PERMIT_WRITE = 6 / DF_PERMIT_DELETE = 7
					int userPermit = document.getPermit();
					if(userPermit < IDfACL.DF_PERMIT_WRITE){
						throw new RuntimeException("Current user has is not authorized to upload a document ");
					}
					document.setObjectName(objectName);
					document.setInt("company_id", companyId);

					if (personId > 0) {
						((IDfAspects) document).attachAspect("my_huo_aspect", new IDfAttachAspectCallback() {
							@Override
							public void doPostAttach(IDfPersistentObject arg0) throws Exception {
								arg0.setInt("my_huo_aspect.person_id", personId);
							}
						});
					}
					File file = null;
					try {
						if (StringUtils.isNotBlank(content.getFormat())) {
							document.setContentType(content.getFormat());
						} else {
							String dosExtension = StringUtils.trimToEmpty(FilenameUtils.getExtension(objectName)).toLowerCase();
							String format = getFormatFromDosExtension(dfSession, dosExtension); // see dm_format
							document.setContentType(format);
						}
						if (content.canGetAsFile()) {
							file = content.getAsFile();
						} else {
							file = File.createTempFile(document.getTypeName() + "_", ".tmp");
							InputStream inputStream = new ByteArrayInputStream(content.getAsByteArray());
							try {
								OutputStream outputStream = new FileOutputStream(file);
								try {
									IOUtils.copy(inputStream, outputStream);
								} finally {
									outputStream.close();
								}
							} finally {
								inputStream.close();
							}
						}
						document.setFile(file.getCanonicalPath());
						document.save();
					} finally {
						if (file != null) {
							file.delete();
						}
					}
					objectId = document.getObjectId().getId();
					noError = true;
				} finally {
					if (transaction) {
						if (noError) {
							dfSession.commitTrans();
						} else {
							dfSession.abortTrans();
						}
					}
				}
			} finally {
				dfSession.getSessionManager().release(dfSession);
			}
		} catch (Throwable th) {
			String message = MessageFormat.format("uploadDocument({0}, {1,number,#0}, {2,number,#0}, {3,number,#0}, {4}, {5}) failed", objectName, companyId, personId, content);
			dfsLogger.error(message, th);
		}
		return objectId;
	}

	private static DataHandlerContent getDataHandlerContent(Content content) throws ContentTransformationException {
		IServiceContext serviceContext = ContextFactory.getInstance().getContext();
		ContentTransferProfile contentTransferProfile = serviceContext.getProfile(ContentTransferProfile.class);
		return getDataHandlerContent(content, contentTransferProfile);
	}
	

	private static IQueryService getQueryService(IServiceContext serviceContext, boolean updateContext, String repository) throws Exception {
		return (IQueryService) getService(com.emc.documentum.fs.services.core.client.IQueryService.class, serviceContext, updateContext, repository);
	}

	private static Object getService(Class<?> serviceClass, IServiceContext serviceContext, boolean updateContext, String repository) throws Exception {
		return ServiceFactory.getInstance().getLocalService(serviceClass, serviceContext);
	}
	private static IObjectService getObjectService(IServiceContext serviceContext, boolean updateContext, String repository) throws Exception {
		return (IObjectService) getService(IObjectService.class, serviceContext, updateContext, repository);
	}


	private static DataHandlerContent getDataHandlerContent(Content content, ContentTransferProfile contentTransferProfile) throws ContentTransformationException {
		DataHandlerContent dataHandlerContent = ContentFactory.getInstance().toDataHandlerContent(content);
		if (contentTransferProfile == null || contentTransferProfile.getTransferMode() == null) {
			contentTransferProfile = new ContentTransferProfile();
		}
		dataHandlerContent.setContentTransferMode(contentTransferProfile.getTransferMode());
		return dataHandlerContent;
	}


	 private IDfSession getDfSession(String user, String passwd, String docbase) throws Exception {		
		IDfLoginInfo login = new DfLoginInfo();
		login.setUser(user);
		login.setPassword(passwd);
		IDfClient client = DfClient.getLocalClient(); //new DfClient();
		IDfSessionManager sessMgr = client.newSessionManager();
		sessMgr.setIdentity(docbase, login);
		IDfSession idfSession = sessMgr.getSession(docbase);

		if (idfSession != null)
			System.out.println("Session created successfully");

		return idfSession;
	}

That’s all!!!

Huseyin OZVEREN

Tags: Creation, DFS, Documentum, ecm, Service, web

Comments (0)

Documentum : DFC : Standalone Sample Program : All Basic Functionalities of Documentum

10
Nov

posted by Huseyin OZVEREN filed under DFC DCTM, Documentum, TOOLS DCTM

Hi,

Here, a very useful class exposing a lot of functionalities of Documentum (found on the Internet https://worldofchaitu.wordpress.com/2012/11/08/documentum-dfc-standalone-sample-program/):

To get a list of available docbase
To create a cabinet (dm_cabinet) in docbase
To create a folder (dm_folder object) in docbase
To create a document (dm_document object) in docbase
To check out a document from docbase using IDfOperations
To check in a document to docbase using IDfOperations making use of IAPI methods
To import a document into docbase
To cancelcheckout a document into docbase
To check out a document from docbase
To check in a document to docbase
To delete a document from docbase
To update document’s in docbase
To retrieve document’s attributes from docbase
To create a virtual document in docbase
To export a virtual document from docbase
To view virtual document from docbase
To retrieve document from document using IDQL
To create and start workflow
To view task in inbox
To attach a lifeCycle to a document in docbase
To promote a lifeCycle state of a document
To demote a lifeCycle state of a document
To expire a lifeCycle state of a document
To resume a lifeCycle state of a document
To assign a ACL to a document

package com.huo.test.ecm.test1;

import java.util.ArrayList;
import java.util.GregorianCalendar;
import java.util.List;
import java.util.StringTokenizer;

import com.documentum.com.DfClientX;
import com.documentum.com.IDfClientX;
import com.documentum.fc.client.DfClient;
import com.documentum.fc.client.DfQuery;
import com.documentum.fc.client.IDfACL;
import com.documentum.fc.client.IDfActivity;
import com.documentum.fc.client.IDfClient;
import com.documentum.fc.client.IDfCollection;
import com.documentum.fc.client.IDfDocbaseMap;
import com.documentum.fc.client.IDfDocument;
import com.documentum.fc.client.IDfFolder;
import com.documentum.fc.client.IDfProcess;
import com.documentum.fc.client.IDfQuery;
import com.documentum.fc.client.IDfQueueItem;
import com.documentum.fc.client.IDfSession;
import com.documentum.fc.client.IDfSessionManager;
import com.documentum.fc.client.IDfSysObject;
import com.documentum.fc.client.IDfType;
import com.documentum.fc.client.IDfTypedObject;
import com.documentum.fc.client.IDfVirtualDocument;
import com.documentum.fc.client.IDfVirtualDocumentNode;
import com.documentum.fc.client.IDfWorkflow;
import com.documentum.fc.client.IDfWorkflowBuilder;
import com.documentum.fc.client.IDfWorkitem;
import com.documentum.fc.common.DfList;
import com.documentum.fc.common.DfLoginInfo;
import com.documentum.fc.common.IDfAttr;
import com.documentum.fc.common.IDfId;
import com.documentum.fc.common.IDfList;
import com.documentum.fc.common.IDfLoginInfo;
import com.documentum.operations.IDfCancelCheckoutNode;
import com.documentum.operations.IDfCancelCheckoutOperation;
import com.documentum.operations.IDfCheckinNode;
import com.documentum.operations.IDfCheckinOperation;
import com.documentum.operations.IDfCheckoutNode;
import com.documentum.operations.IDfCheckoutOperation;
import com.documentum.operations.IDfExportNode;
import com.documentum.operations.IDfExportOperation;
import com.documentum.operations.IDfImportNode;
import com.documentum.operations.IDfImportOperation;
import com.documentum.operations.IDfOperation;
import com.documentum.operations.IDfOperationError;

/**
 See https://webcache.googleusercontent.com/search?q=cache:MW2FjC-Rg7YJ:https://worldofchaitu.wordpress.com/2012/11/08/documentum-dfc-standalone-sample-program/+&cd=3&hl=en&ct=clnk&gl=lu
 Documentum DFC Standalone Sample Program


 This blog contains sample DFC code snippet of all basic functionalities of Documentum

 To get a list of available docbase
 To create a cabinet (dm_cabinet) in docbase
 To create a folder (dm_folder object) in docbase
 To create a document (dm_document object) in docbase
 To check out a document from docbase using IDfOperations
 To check in a document to docbase using IDfOperations making use of IAPI methods
 To import a document into docbase
 To cancelcheckout a document into docbase
 To check out a document from docbase
 To check in a document to docbase
 To delete a document from docbase
 To update document's in docbase
 To retrieve document's attributes from docbase
 To create a virtual document in docbase
 To export a virtual document from docbase
 To view virtual document from docbase
 To retrieve document from document using IDQL
 To create and start workflow
 To view task in inbox
 To attach a lifeCycle to a document in docbase
 To promote a lifeCycle state of a document
 To demote a lifeCycle state of a document
 To expire a lifeCycle state of a document
 To resume a lifeCycle state of a document
 To assign a ACL to a document
**/

public class DFCWorkShop {

	IDfSysObject sysObject = null;
	IDfSession idfSession = null;
	IDfSessionManager sessMgr = null;

	public DFCWorkShop(String user, String passwd, String docbase) throws Exception {
		getDfSession(user, passwd, docbase);
	}

	public IDfSession getDfSession(String args1, String args2, String args3)
			throws Exception {
		
		IDfLoginInfo login = new DfLoginInfo();
		login.setUser(args1);
		login.setPassword(args2);
		IDfClient client = DfClient.getLocalClient(); //new DfClient();
		sessMgr = client.newSessionManager();
		sessMgr.setIdentity(args3, login);
		idfSession = sessMgr.getSession(args3);

		if (idfSession != null)
			System.out.println("Session created successfully");

		return idfSession;
	}


	public void releaseSession() throws Exception {
		sessMgr.release(idfSession);
	}
	
	public void getAllDocbases() throws Exception {

		IDfClient client = DfClient.getLocalClient();
		IDfDocbaseMap docbaseMap = client.getDocbaseMap();
		for (int i = 0; i < docbaseMap.getDocbaseCount(); i++) {
			System.out.println("Docbase Name : " + docbaseMap.getDocbaseName(i));
			System.out.println("Docbase Desc : " + docbaseMap.getDocbaseDescription(i));
		}
	}

	public void createCabinet() throws Exception {

		IDfFolder cabinet = (IDfFolder) idfSession.newObject("dm_cabinet");
		if (cabinet != null) {
			cabinet.setObjectName("Training Cabinet XXX");
			cabinet.save();
		}
	}

	public void createFolder() throws Exception {

		IDfFolder folder = (IDfFolder) idfSession.newObject("dm_folder");
		if (folder != null) {
			folder.setObjectName("Folder Level 2");
			folder.link("/Training Cabinet XXX");
			folder.save();
		}
	}

	public IDfDocument createDocument() throws Exception {

		IDfDocument document = (IDfDocument) idfSession
				.newObject("dm_document");
		if (document != null) {
			document.setObjectName("Test-Document");
			document.setContentType("crtext");
			document.setFile("C:\\Documentum\\config\\dfc.properties");
			document.link("/Training Cabinet XXX/Folder Level 1");
			document.save();
		}
		return document;
	}

	public void updateAttributes() throws Exception {

		sysObject = (IDfSysObject) idfSession
				.getObjectByPath("/Training Cabinet XXX/Folder Level 1/New Document");
		sysObject.setString("object_name", "New Document");
		sysObject.setString("authors", "Prasad");
		sysObject.setRepeatingString("authors", 1, "RamKumar");
		sysObject.save();
	}

	public void getAttributes() throws Exception {

		sysObject = (IDfSysObject) idfSession
				.getObjectByPath("/Training Cabinet XXX/Folder Level 1/New Document");
		if (sysObject != null) {
			System.out.println("objectName "
					+ sysObject.getString("object_name"));
			// System.out.println("authors " + sysObject.getString("authors"));
			String authors = sysObject.getAllRepeatingStrings("authors", ",");

			List list = new ArrayList();
			StringTokenizer st = new StringTokenizer(authors, ",");
			System.out.println("length of st " + st.countTokens());
			while (st.hasMoreTokens()) {
				list.add(st.nextElement());
			}
			System.out.println("length " + list.size());

			for (int i = 0; i < list.size(); i++) {
				System.out.println("Author[" + i + "] " + list.get(i));
			}
		}
	}

	public void getTypeAttributes() throws Exception {

		IDfType type = (IDfType) idfSession.newObject("dm_document");
		for (int i = 0; i < type.getAttrCount(); i++) {
			IDfAttr attr = type.getAttr(i);
			System.out.println("Name " + attr.getName());
			System.out.println("Datatype " + attr.getDataType());
			System.out.println("Length " + attr.getLength());
			System.out.println("IS Repeating Attr " + attr.isRepeating());
		}
	}

	public void checkoutDoc() throws Exception {

		sysObject = (IDfSysObject) idfSession
				.getObjectByPath("/Training Cabinet XXX/Folder Level 1/");
		if (!sysObject.isCheckedOut()) // if it is not checked out
			sysObject.checkout();

		System.out.println("is Check out " + sysObject.isCheckedOut());
	}

	public void checkinDoc() throws Exception {

		sysObject = (IDfSysObject) idfSession
				.getObjectByPath("/Training Cabinet XXX/Folder Level 1/Test-Document");

		if (sysObject.isCheckedOut()) { // if it is checked out
			sysObject.checkin(false, "CURRENT");
		}
	}

	public void deleteDoc() throws Exception {

		sysObject = (IDfSysObject) idfSession
				.getObjectByPath("/Training Cabinet XXX/Folder Level 1/Test-Document");
		if (sysObject != null) {
			sysObject.destroyAllVersions(); // delete all versions
			System.out.println("object destroyed…..");
		}
	}

	public void createVirtualDocument() throws Exception {

		IDfSysObject pSys = (IDfSysObject) idfSession
				.getObjectByPath("/Training Cabinet XXX/Folder Level 2/log4j.properties");
		IDfSysObject cSys = (IDfSysObject) idfSession
				.getObjectByPath("/Training Cabinet XXX/Folder Level 1/trace.log");

		pSys.setIsVirtualDocument(true);
		pSys.save();
		IDfVirtualDocument vDoc = pSys.asVirtualDocument("CURRENT", false);
		IDfVirtualDocumentNode pNode = vDoc.getRootNode();
		pSys.checkout();

		IDfVirtualDocumentNode nodeChild1 = vDoc.addNode(pNode, null, cSys
				.getChronicleId(), "CURRENT", false, false);

		pSys.checkin(false, "CURRENT");
	}

	public void viewVirtualDocument() throws Exception {

		IDfSysObject pSys = (IDfSysObject) idfSession
				.getObjectByPath("/Training Cabinet XXX/Folder Level 2/log4j.properties");
		if (pSys.isVirtualDocument()) {
			System.out.println("virtual document –> true");
			IDfVirtualDocument vDoc = pSys.asVirtualDocument("CURRENT", false);
			IDfVirtualDocumentNode pNode = vDoc.getRootNode();

			System.out.println("Iterating thru the lis to get the child nodes");
			for (int i = 0; i < pNode.getChildCount(); i++) {
				IDfVirtualDocumentNode cNode = pNode.getChild(i);
				System.out.println("Child Name "
						+ cNode.getSelectedObject().getObjectName());
			}
		}
	}

	public void exportVirtualDocument() throws Exception {

		System.out.println("exporting virtual document");

		IDfClientX clientx = new DfClientX();
		IDfExportOperation expOperation = clientx.getExportOperation();

		IDfSysObject sysObject = (IDfSysObject) idfSession
				.getObjectByPath("/Training Cabinet XXX/Folder Level 2/log4j.properties");
		if (sysObject.isVirtualDocument()) {
			IDfVirtualDocument Vdoc = sysObject.asVirtualDocument("CURRENT",
					false);
			IDfExportNode expNode = (IDfExportNode) expOperation.add(sysObject);
			expOperation.setDestinationDirectory(expOperation
					.getDefaultDestinationDirectory());
			boolean flag = expOperation.execute();
			displayError(expOperation, flag);
		}
	}

	public void cancelCheckoutDocument() throws Exception {

		IDfClientX clientx = new DfClientX();
		IDfCancelCheckoutOperation cancelcheckoutOper = clientx
				.getCancelCheckoutOperation();
		sysObject = (IDfSysObject) idfSession
				.getObjectByPath("/Training Cabinet XXX/Folder Level 2/log4j.properties");

		IDfCancelCheckoutNode node = (IDfCancelCheckoutNode) cancelcheckoutOper
				.add(sysObject);
		boolean flag = cancelcheckoutOper.execute();
		displayError(cancelcheckoutOper, flag);
	}

	public void checkoutDocument() throws Exception {

		IDfClientX clientx = new DfClientX();
		IDfCheckoutOperation checkoutOper = clientx.getCheckoutOperation();

		System.out.println("Checkout Dir "
				+ checkoutOper.getDefaultDestinationDirectory());
		checkoutOper.setDestinationDirectory(checkoutOper
				.getDefaultDestinationDirectory());

		sysObject = (IDfSysObject) idfSession
				.getObjectByPath("/Training Cabinet XXX/Folder Level 2/log4j.properties");

		IDfCheckoutNode node = (IDfCheckoutNode) checkoutOper.add(sysObject);
		boolean flag = checkoutOper.execute();
		displayError(checkoutOper, flag);

	}

	public void checkinDocument() throws Exception {

		IDfClientX clientx = new DfClientX();
		IDfCheckinOperation checkinOper = clientx.getCheckinOperation();

		IDfCheckinNode node = (IDfCheckinNode) checkinOper.add(sysObject);
		System.out.println("Flag —->" + checkinOper.execute());
	}

	public void importDocument() throws Exception {

		IDfSysObject sysObject = (IDfFolder) idfSession
				.getObjectByPath("/Training Cabinet XXX/Folder Level 2");
		System.out.println("Object ID " + sysObject.getObjectId());

		IDfClientX clientx = new DfClientX();
		IDfImportOperation importOper = clientx.getImportOperation();
		importOper.setSession(idfSession);

		if (importOper == null)
			System.out.println("operation object is null");

		importOper.setDestinationFolderId(sysObject.getObjectId());
		importOper.setVersionLabels("imported using operation");

		IDfImportNode node = (IDfImportNode) importOper
				.add("C:\\Documentum\\config\\log4j.properties");
		node.setFormat("pdf");

		boolean flag = importOper.execute();
		displayError(importOper, flag);
	}

	public void displayError(IDfOperation operation, boolean flag)
			throws Exception {

		if (!flag) {

			IDfList errlist = operation.getErrors();

			for (int i = 0; i < errlist.getCount(); i++) {
				IDfOperationError errOperation = (IDfOperationError) errlist
						.get(i);
				System.out.println("Error MSG " + errOperation.getMessage());
			}
		}
	}

	public void dmclAPI() throws Exception {

		System.out.println("Starting...");
		IDfSysObject sysObj = (IDfSysObject) idfSession
				.getObjectByQualification("dm_document where object_name='Test-Document'");
		String rObjectId = sysObj.getObjectId().getId();

		String name = (String) idfSession.apiGet("get", rObjectId+ ",object_name");
		System.out.println("Name : " + name);
		// idfSession.apiSet("set",rObjectId+",title","sample-doc");
		idfSession.apiExec("link",rObjectId+",/Training Cabinet XXX/Folder Level 2");
		System.out.println("Linked " + idfSession.apiExec("save", rObjectId));
	}

	public void collection() throws Exception {

		IDfQuery query = new DfQuery();
		query
				.setDQL("select * from dm_document where object_name='New Document' and any r_version_label like 'CURRENT%'");
		IDfCollection coll = query.execute(idfSession, 0);

		while (coll.next()) {
			IDfTypedObject typeObject = (IDfTypedObject) coll.getTypedObject();
			System.out.println("Object Name "
					+ typeObject.getString("r_object_id"));
			System.out.println("creation date "
					+ typeObject.getString("r_creation_date"));
		}

		if (coll != null)
			coll.close();
	}

	public void startWorkflow() throws Exception {

		// to get the attachment document
		IDfSysObject sysObj = (IDfSysObject) idfSession
				.getObjectByQualification("dm_document where object_name='DFCtest'");

		// to get the Workflow Template
		IDfProcess process = (IDfProcess) idfSession
				.getObjectByQualification("dm_process where object_name like '%INDIA_TIMES%'");

		// to create a Workflo Builder to start a workflow
		IDfWorkflowBuilder builder = idfSession.newWorkflowBuilder(process
				.getObjectId());
		IDfId wfId = builder.initWorkflow();

		// get the First Activity
		IDfList startActivityNames = builder.getStartActivityNames();
		IDfList startActivities = builder.getStartActivityIds();
		String activityName = startActivityNames.getString(0);
		IDfId activityID = (IDfId) startActivities.get(0);
		IDfActivity activity = (IDfActivity) idfSession.getObject(activityID);

		// to get the Package Name , Port and Package DocType
		int nPorts = activity.getPortCount();
		String InputPortName = null;
		String PkgType = null;
		String PkgName = null;

		for (int j = 0; j < nPorts; j++) {
			System.out.println("Port Name: " + activity.getPortName(j) + ", "
					+ "Port Type = " + activity.getPortType(j));

			if (activity.getPortType(j).equals("INPUT")) {
				InputPortName = activity.getPortName(j);
				PkgType = activity.getPackageType(j);
				PkgName = activity.getPackageName(j);
			}
		}

		// to Add the attachment document to List
		IDfList dfList = new DfList();
		dfList.append(sysObj.getObjectId());

		IDfId wfId2 = builder.runWorkflow();
		// Add a Package to Workflow Builder
		builder.addPackage(activityName, InputPortName, PkgName, PkgType, null,
				false, dfList);
		System.out.println("package added");

	}

	public void getInbox() throws Exception {
		// IDfCollection getTasks(String userName, int filter, String additionalAttributes, String orderBy)
		IDfCollection tasks = idfSession.getTasks("huoadm", IDfSession.DF_TASKS, "name, date_sent, message ", "task_name");

		try {
			while (tasks.next()) {
				IDfWorkitem wi = (IDfWorkitem) idfSession.getObject(tasks.getId("item_id"));
				IDfId queueItemId = wi.getQueueItemId();
				IDfQueueItem qi = (IDfQueueItem) idfSession.getObject(queueItemId);
				System.out.println(tasks.getString("sent_by") + "   "
								+ tasks.getString("task_name") + "   "
								+ tasks.getString("date_sent") + "   "
								+ tasks.getString("message") + "   "
								+ qi.getItemName());
				IDfActivity dfActivity = wi.getActivity();
				System.out.println("\tActivity Information : " + dfActivity.getString("object_name"));
				IDfCollection packColl = null;
				try {
					packColl = wi.getPackages("");
					while (packColl.next()) {
						IDfSysObject sysObj = (IDfSysObject) idfSession.getObject(packColl.getId("r_component_id"));
						System.out.println("\t Package Information: " + sysObj.getString("object_name"));
					}
					
				} finally {
					if (packColl != null)
						packColl.close();
				}
				// to finish a Task or Workitem
				// finishTask(wi);
			}
		} finally {
			if (tasks != null)
				tasks.close();
		}
	}

	public void finishTask(IDfWorkitem wi) throws Exception {

		if (wi.getRuntimeState() == IDfWorkflow.DF_WF_STATE_DORMANT) {
			wi.acquire();
		}
		wi.complete();
	}

	public void attachLC() throws Exception {

		IDfSysObject mDocs = (IDfSysObject) idfSession
				.getObjectByQualification("dm_document where object_name='UniqueDoc' ");

		IDfSysObject procObj = (IDfSysObject) idfSession
				.getObjectByQualification("dm_policy where object_name='Training_LC' ");
		mDocs.attachPolicy(procObj.getObjectId(), "Author", "");

	}

	public void promoteLC(String State) throws Exception {
		IDfSysObject mDocs = (IDfSysObject) idfSession
				.getObjectByQualification("dm_document where object_name='UniqueDoc' ");
		mDocs.promote(State, false, false);
	}

	public void demoteLC(String State) throws Exception {
		IDfSysObject mDocs = (IDfSysObject) idfSession
				.getObjectByQualification("dm_document where object_name='UniqueDoc' ");
		mDocs.demote(State, false);
	}

	public void expireLC(String State) throws Exception {
		IDfSysObject mDocs = (IDfSysObject) idfSession
				.getObjectByQualification("dm_document where object_name='UniqueDoc' ");
		mDocs.suspend(State, false, false);
	}

	public void resumeLC(String State) throws Exception {
		IDfSysObject mDocs = (IDfSysObject) idfSession
				.getObjectByQualification("dm_document where object_name='UniqueDoc' ");
		mDocs.resume(State, false, false, false);
	}


	public void assignACL() throws Exception {

		IDfSysObject mDocs = (IDfSysObject) idfSession
				.getObjectByQualification("dm_document where object_name='UniqueDoc' ");
		IDfACL dfACL = (IDfACL) idfSession
				.getObjectByQualification("dm_acl where object_name='TrainingACL' ");
		mDocs.setACL(dfACL);
		mDocs.save();
	}

	
	public static void main(String[] args) throws Exception {

		String user = "huoadm";
		String passwd = "pass_4_huoadm";
		String docbase = "MY_DOCBASE_DEV";
		DFCWorkShop object = new DFCWorkShop(user, passwd, docbase);

		try {

			// To get a list of available docbase
			/*
				Session created successfully
				Docbase Name : MY_DOCBASE2_DEV
				Docbase Desc : Company Repository 2
				Docbase Name : MY_DOCBASE_DEV
				Docbase Desc : Company Repository
				Docbase Name : GLOBALR
				Docbase Desc : Global Registry Repository
				Docbase Name : MY_DOCBASE3_DEV
				Docbase Desc : Company Repository 3
				Docbase Name : MY_DOCBASE4_DEV
				Docbase Desc : Company Repository 4 
			 */
//			object.getAllDocbases();

			// To create a cabinet (dm_cabinet) in docbase
			// object.createCabinet();

			// To create a folder (dm_folder object) in docbase
			// object.createFolder();

			// To create a document (dm_document object) in docbase
			// object.createDocument();

			// To check out a document from docbase using IDfOperations
			// object.checkoutDocument();

			// To check in a document to docbase using IDfOperations
			// object.checkinDocument();

			// making use of IAPI methods
			// object.dmclAPI();

			// To import a document into docbase
			// object.importDocument();

			// To cancelcheckout a document into docbase
			// object.cancelCheckoutDocument();

			// To check out a document from docbase
			// object.checkoutDoc();

			// To check in a document to docbase
			// object.checkinDoc();

			// To delete a document from docbase
			// object.deleteDoc();

			// To update document's in docbase
			// object.updateAttributes();

			// To retrieve document's attributes from docbase
			// object.getAttributes();

			// To create a virtual document in docbase
			// object.createVirtualDocument();

			// To export a virtual document from docbase
			// object.exportVirtualDocument();

			// To view virtual document from docbase
			// object.viewVirtualDocument();

			// To retrieve document from document using IDQL
			// object.collection();

			// To create and start workflow
			// object.startWorkflow();

			// to view task in inbox
			 object.getInbox();

			// To attach a lifeCycle to a document in docbase
			// object.attachLC();

			// To promote a lifeCycle state of a document
			// object.promoteLC("Review");

			// To demote a lifeCycle state of a document
			// object.demoteLC("Author");

			// To expire a lifeCycle state of a document
			// object.expireLC("Author");

			// To resume a lifeCycle state of a document
			// object.resumeLC("Author");

			// To assign a ACL to a document
			// object.assignACL();

		} finally {
			// to release a docbase session
			object.releaseSession();
		}
	}
}

Kind regards,

Huseyin

Tags: Basic, DFC, Documentum, Functionalities, Program, Sample, Standalone, useful

Comments (0)

Page 5 of 54:« First « 2 3 4 5 6 7 8 »Last »

JavaBlog.fr / Java.lu

OLDER ARTICLES

CSharp/C# : Get the source folder path of CSharp class

CSharp/C# : Generate Custom Types from XSD file, XmlSerializer, XML Validation

Generate Custom Types from XSD file

Serialization of objects to XML

Validation of XML with XSD file

Documentum : Creation of DFS Web Service

DFS Service Creation

DFS Service Client Creation

Documentum : DFC : Standalone Sample Program : All Basic Functionalities of Documentum

RSS Feeds

Categories

Archives

Recent Posts

JavaBlog.fr / Java.lu NewsLetter

Most Commented

Random Articles

Featured not set yet