external-software/github_OpenIdentityPlatform_OpenDJ.git

			@@ -22,19 +22,24 @@
			* CDDL HEADER END
			*
			*
			* Copyright 2006-2008 Sun Microsystems, Inc.
			* Copyright 2006-2009 Sun Microsystems, Inc.
			*/
			package org.opends.server.tools.makeldif;



			import java.io.BufferedWriter;
			import java.io.IOException;
			import java.util.ArrayList;
			import java.util.LinkedHashMap;
			import java.util.List;

			import org.opends.server.core.DirectoryServer;
			import org.opends.server.types.*;
			import org.opends.server.util.LDIFException;

			import static org.opends.server.util.LDIFWriter.appendLDIFSeparatorAndValue;
			import static org.opends.server.util.LDIFWriter.writeLDIFLine;
			import static org.opends.server.util.StaticUtils.*;


			@@ -273,21 +278,36 @@
			}



			/**
			* Retrieves this template entry as an <CODE>Entry</CODE> object.
			* Writes this entry in LDIF form. No filtering will be
			* performed for this entry, nor will any export plugins be invoked.
			*
			* @return The <CODE>Entry</CODE> object for this template entry.
			* @param exportConfig The configuration that specifies how the
			* entry should be written.
			*
			* @return <CODE>true</CODE> if the entry is actually written, or
			* <CODE>false</CODE> if it is not for some reason.
			*
			* @throws IOException If a problem occurs while writing the
			* information.
			*
			* @throws LDIFException If a problem occurs while trying to
			* determine whether to write the entry.
			*/
			public Entry toEntry()
			public boolean toLDIF(LDIFExportConfig exportConfig)
			throws IOException, LDIFException
			{
			// Process all of the attributes for this entry.
			// Process all of the attributes for this entry.
			LinkedHashMap<ObjectClass,String> objectClasses =
			new LinkedHashMap<ObjectClass,String>();
			LinkedHashMap<AttributeType,List<Attribute>> userAttributes =
			new LinkedHashMap<AttributeType,List<Attribute>>();
			LinkedHashMap<AttributeType,List<Attribute>> operationalAttributes =
			new LinkedHashMap<AttributeType,List<Attribute>>();
			LinkedHashMap<AttributeType, List<Attribute>> urlAttributes =
			new LinkedHashMap<AttributeType, List<Attribute>>();
			LinkedHashMap<AttributeType, List<Attribute>> base64Attributes =
			new LinkedHashMap<AttributeType, List<Attribute>>();

			for (AttributeType t : attributes.keySet())
			{
			@@ -316,19 +336,237 @@
			else
			{
			AttributeBuilder builder = new AttributeBuilder(t, t.getNameOrOID());
			AttributeBuilder urlBuilder = null;
			AttributeBuilder base64Builder = null;
			for (TemplateValue v : valueList)
			{
			builder.add(AttributeValues.create(t, v.getValue().toString()));
			AttributeValue value =
			AttributeValues.create(t, v.getValue().toString());
			builder.add(value);
			if (v.getTemplateLine().isURL())
			{
			if (urlBuilder == null)
			{
			urlBuilder = new AttributeBuilder(t, t.getNameOrOID());
			}
			urlBuilder.add(value);
			}
			else if (v.getTemplateLine().isBase64())
			{
			if (base64Builder == null)
			{
			base64Builder = new AttributeBuilder(t, t.getNameOrOID());
			}
			base64Builder.add(value);
			}
			}

			ArrayList<Attribute> attrList = new ArrayList<Attribute>(1);
			attrList.add(builder.toAttribute());
			userAttributes.put(t, attrList);

			if (urlBuilder != null)
			{
			ArrayList<Attribute> urlAttrList = new ArrayList<Attribute>(1);
			urlAttrList.add(urlBuilder.toAttribute());
			urlAttributes.put(t, urlAttrList);
			}

			if (base64Builder != null)
			{
			ArrayList<Attribute> base64AttrList = new ArrayList<Attribute>(1);
			base64AttrList.add(base64Builder.toAttribute());
			base64Attributes.put(t, base64AttrList);
			}
			}
			}

			return new Entry(getDN(), objectClasses, userAttributes,
			operationalAttributes);
			// Get the information necessary to write the LDIF.
			BufferedWriter writer = exportConfig.getWriter();
			int wrapColumn = exportConfig.getWrapColumn();
			boolean wrapLines = (wrapColumn > 1);


			// First, write the DN. It will always be included.
			StringBuilder dnLine = new StringBuilder();
			dnLine.append("dn");
			appendLDIFSeparatorAndValue(dnLine,
			ByteString.valueOf(getDN().toString()));
			writeLDIFLine(dnLine, writer, wrapLines, wrapColumn);


			// Next, the set of objectclasses.
			final boolean typesOnly = exportConfig.typesOnly();
			if (exportConfig.includeObjectClasses())
			{
			if (typesOnly)
			{
			StringBuilder ocLine = new StringBuilder("objectClass:");
			writeLDIFLine(ocLine, writer, wrapLines, wrapColumn);
			}
			else
			{
			for (String s : objectClasses.values())
			{
			StringBuilder ocLine = new StringBuilder();
			ocLine.append("objectClass: ");
			ocLine.append(s);
			writeLDIFLine(ocLine, writer, wrapLines, wrapColumn);
			}
			}
			}


			// Now the set of user attributes.
			for (AttributeType attrType : userAttributes.keySet())
			{
			if (exportConfig.includeAttribute(attrType))
			{
			List<Attribute> attrList = userAttributes.get(attrType);
			for (Attribute a : attrList)
			{
			if (a.isVirtual() &&
			(! exportConfig.includeVirtualAttributes()))
			{
			continue;
			}

			if (typesOnly)
			{
			StringBuilder attrName = new StringBuilder(a.getName());
			for (String o : a.getOptions())
			{
			attrName.append(";");
			attrName.append(o);
			}
			attrName.append(":");

			writeLDIFLine(attrName, writer, wrapLines, wrapColumn);
			}
			else
			{
			StringBuilder attrName = new StringBuilder(a.getName());
			for (String o : a.getOptions())
			{
			attrName.append(";");
			attrName.append(o);
			}

			List<Attribute> urlAttrList = urlAttributes.get(attrType);
			List<Attribute> base64AttrList = base64Attributes.get(attrType);

			for (AttributeValue v : a)
			{
			StringBuilder attrLine = new StringBuilder();
			attrLine.append(attrName);
			boolean isURLValue = false;
			if (urlAttrList != null)
			{
			for (Attribute urlAttr : urlAttrList)
			{
			for (AttributeValue urlValue : urlAttr)
			{
			if (urlValue.equals(v))
			{
			isURLValue = true;
			break;
			}
			}
			if (isURLValue)
			{
			break;
			}
			}
			}
			boolean isBase64Value = false;
			if (base64AttrList != null)
			{
			for (Attribute base64Attr : base64AttrList)
			{
			for (AttributeValue base64Value : base64Attr)
			{
			if (base64Value.equals(v))
			{
			isBase64Value = true;
			break;
			}
			}
			if (isBase64Value)
			{
			break;
			}
			}
			}
			appendLDIFSeparatorAndValue(attrLine,
			v.getValue(),
			isURLValue,
			isBase64Value);
			writeLDIFLine(attrLine, writer, wrapLines, wrapColumn);
			}
			}
			}
			}
			}


			// Next, the set of operational attributes.
			if (exportConfig.includeOperationalAttributes())
			{
			for (AttributeType attrType : operationalAttributes.keySet())
			{
			if (exportConfig.includeAttribute(attrType))
			{
			List<Attribute> attrList =
			operationalAttributes.get(attrType);
			for (Attribute a : attrList)
			{
			if (a.isVirtual() &&
			(! exportConfig.includeVirtualAttributes()))
			{
			continue;
			}

			if (typesOnly)
			{
			StringBuilder attrName = new StringBuilder(a.getName());
			for (String o : a.getOptions())
			{
			attrName.append(";");
			attrName.append(o);
			}
			attrName.append(":");

			writeLDIFLine(attrName, writer, wrapLines, wrapColumn);
			}
			else
			{
			StringBuilder attrName = new StringBuilder(a.getName());
			for (String o : a.getOptions())
			{
			attrName.append(";");
			attrName.append(o);
			}

			for (AttributeValue v : a)
			{
			StringBuilder attrLine = new StringBuilder();
			attrLine.append(attrName);
			appendLDIFSeparatorAndValue(attrLine,
			v.getValue());
			writeLDIFLine(attrLine, writer, wrapLines,
			wrapColumn);
			}
			}
			}
			}
			}
			}

			// Make sure there is a blank line after the entry.
			writer.newLine();


			return true;
			}
			}