DataDictionary.cs

using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Text;

using System.ComponentModel;
using System.Net;
using System.Web;

using IfcDoc.Format.XML;
using IfcDoc.Schema;
using IfcDoc.Schema.DOC;
using IfcDoc.Schema.PSD;

namespace IfcDoc
{
	public class DataDictionary
	{
		/// <summary>
		/// Connects to Data Dictionary and returns session ID.
		/// </summary>1
		/// <param name="project"></param>
		/// <param name="worker"></param>
		/// <param name="baseurl"></param>
		/// <param name="username"></param>
		/// <param name="password"></param>
		/// <returns></returns>
		public static string Connect(DocProject project, BackgroundWorker worker, string baseurl, string username, string password)
		{
			string url = baseurl + "api/4.0/session/login?email=" + HttpUtility.UrlEncode(username) + "&password=" + HttpUtility.UrlEncode(password);

			HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
			request.Method = "POST";
			request.ContentLength = 0;
			request.ContentType = "application/x-www-form-urlencoded";
			request.Accept = "application/json";
			HttpWebResponse response = (HttpWebResponse)request.GetResponse();
			System.IO.Stream stream = response.GetResponseStream();
			System.IO.StreamReader reader = new System.IO.StreamReader(stream);
			string body = reader.ReadToEnd();

			string cookie = response.Headers.Get("Set-Cookie");

			string[] parts = cookie.Split(new char[] { ';', ',' }); // bug? comma separates session ID
			string match = "peregrineapisessionid=";
			string sessionid = null;
			foreach (string part in parts)
			{
				if (part.StartsWith(match))
				{
					sessionid = part.Substring(match.Length);
					break;
				}
			}

			return sessionid;
		}

		public static ResponseContext GetContexts(DocProject docProject, BackgroundWorker worker, string baseurl, string username, string password)
		{
			string sessionid = Connect(docProject, worker, baseurl, username, password);
			string url = baseurl + "api/4.0/IfdContext/currentUserHasReadAccess";
			HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
			request.Accept = "application/json";
			request.Headers.Add("cookie", "peregrineapisessionid=" + sessionid);
			HttpWebResponse response = (HttpWebResponse)request.GetResponse();
			Stream stream = response.GetResponseStream();

			ResponseContext ifdRoot = null;
			try
			{
				DataContractJsonSerializerSettings settings = new DataContractJsonSerializerSettings();
				DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(ResponseContext));
				ifdRoot = (ResponseContext)ser.ReadObject(stream);
			}
			catch
			{
			}

			return ifdRoot;
		}

		/// <summary>
		/// Gets child concepts
		/// </summary>
		/// <param name="docProject"></param>
		/// <param name="worker"></param>
		/// <param name="baseurl"></param>
		/// <param name="username"></param>
		/// <param name="password"></param>
		/// <param name="ifdParent"></param>
		/// <param name="direction">True for children, False for parents</param>
		/// <returns></returns>
		public static IList<IfdConceptInRelationship> GetConcepts(DocProject docProject, BackgroundWorker worker, string baseurl, string username, string password, IfdConceptInRelationship ifdParent, bool direction)
		{
			SortedList<string, IfdConceptInRelationship> list = new SortedList<string, IfdConceptInRelationship>();

			string sessionid = Connect(docProject, worker, baseurl, username, password);

			// get children
			string nextpage = null;
			do
			{
				string url = baseurl + "api/4.0/IfdConcept/" + ifdParent.guid;
				if (direction)
				{
					url += "/children";//filter/SUBJECT"; // ifc-2X4
				}
				else
				{
					url += "/parents";
				}

				if (nextpage != null)
				{
					url += "?page=" + nextpage;
				}

				HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
				request.Accept = "application/json";
				request.Headers.Add("cookie", "peregrineapisessionid=" + sessionid);
				HttpWebResponse response = (HttpWebResponse)request.GetResponse();
				nextpage = response.Headers.Get("Next-Page");
				Stream stream = response.GetResponseStream();

				ResponseConceptInRelationship responseSearch = null;
				try
				{
					DataContractJsonSerializerSettings settings = new DataContractJsonSerializerSettings();
					DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(ResponseConceptInRelationship));
					responseSearch = (ResponseConceptInRelationship)ser.ReadObject(stream);
					if (responseSearch != null)
					{
						foreach (IfdConceptInRelationship ifdRel in responseSearch.IfdConceptInRelationship)
						{
							list.Add(ifdRel.ToString(), ifdRel);
						}
					}
				}
				catch
				{
					break;
				}
			}
			while (!String.IsNullOrEmpty(nextpage));

			return list.Values;
		}

		public static void Download(DocProject project, BackgroundWorker worker, string baseurl, string username, string password, DocModelView[] docViews)
		{
			string sessionid = Connect(project, worker, baseurl, username, password);
			if (sessionid == null)
				return;

			//foreach (DocModelView docView in docViews)
			string page = null;
			do
			{
				//string url = baseurl + "api/4.0/IfdContext/" + SGuid.Format(docView.Uuid);
				string url = baseurl + "api/4.0/IfdConcept/filter/SUBJECT"; // ifc-2X4
																			//string url = baseurl + "api/4.0/IfdConcept/search/filter/language/1ASQw0qJqHuO00025QrE$V/*";//type/SUBJECT/*";
				if (page != null)
				{
					url += "?page=" + page;
				}

				HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
				request.Accept = "application/json";
				request.Headers.Add("cookie", "peregrineapisessionid=" + sessionid);
				HttpWebResponse response = (HttpWebResponse)request.GetResponse();
				Stream stream = response.GetResponseStream();

				page = response.Headers.Get("Next-Page");
				System.Diagnostics.Debug.WriteLine(page);

				ResponseSearch responseSearch = null;
				try
				{
					DataContractJsonSerializerSettings settings = new DataContractJsonSerializerSettings();
					DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(ResponseSearch));
					responseSearch = (ResponseSearch)ser.ReadObject(stream);
					if (responseSearch != null)
					{
						responseSearch.ToString();

						foreach (IfdConcept ifdConcept in responseSearch.IfdConcept)
						{
							DocModelView docView = new DocModelView();

							if (ifdConcept.shortNames != null)
							{
								foreach (IfdName ifdName in ifdConcept.shortNames)
								{
									DocLocalization docLoc = new DocLocalization();
									docLoc.Locale = ifdName.language.languageCode;
									docLoc.Name = ifdName.name;
									docView.Localization.Add(docLoc);

									if (ifdName.language.languageCode == "en")
									{
										docView.Name = ifdName.name;
									}
								}
							}
							else if (ifdConcept.fullNames != null)
							{
								ifdConcept.ToString();
							}

							docView.Uuid = SGuid.Parse(ifdConcept.guid);
							docView.Version = ifdConcept.versionId;
							docView.Copyright = ifdConcept.versionDate;
							docView.Status = ifdConcept.status;
							//docView.Owner = ifdConcept.owner;
							//docView.Documentation = ifdConcept.comments

							project.ModelViews.Add(docView);

							ifdConcept.ToString();
						}
						//foreach (IfdDescription ifcDesc in ifdContext.definitions)
						{
							// create/update concept root
							//...
						}
					}
				}
				catch (Exception xx)
				{
					xx.ToString();
				}

			}
			while (!String.IsNullOrEmpty(page));
		}

		public static void Upload(DocProject docProject, BackgroundWorker worker, string baseurl, string username, string password, string parentid, DocModelView[] docViews)
		{
			string sessionid = Connect(docProject, worker, baseurl, username, password);

#if false
            if (docViews != null && docViews.Length > 0)
            {
                foreach (DocModelView docView in docViews)//docProject.ModelViews)
                {
                    // hack: only bridge view for now
                    if (docView.Name.Contains("Bridge"))
                    {
                        string codename = docView.Name;
                        if (!String.IsNullOrEmpty(docView.Code))
                        {
                            codename = docView.Code;
                        }

                        IfdBase ifdView = CreateConcept(baseurl, sessionid, docView, codename, docView.Name, IfdConceptTypeEnum.BAG);
                        //CreateRelationship(baseurl, sessionid, parentid, ifdView.guid, "COLLECTS"); // no top-level item for now

                        foreach (DocConceptRoot docRoot in docView.ConceptRoots)
                        {
                            if (docRoot.Name != null)
                            {
                                System.Diagnostics.Debug.WriteLine(docRoot.ToString());

                                IfdBase ifdRoot = CreateConcept(baseurl, sessionid, docRoot, docRoot.ApplicableEntity.Name, docRoot.Name, IfdConceptTypeEnum.SUBJECT);
                                CreateRelationship(baseurl, sessionid, ifdView.guid, ifdRoot.guid, IfdRelationshipTypeEnum.COLLECTS);

                                foreach (DocTemplateUsage docConc in docRoot.Concepts)
                                {
                                    UploadTemplateUsage(docProject, baseurl, sessionid, ifdRoot.guid, docConc);
                                }
                            }
                        }
                    }
                }
            }
            else
#endif
			{
				// build list of types referenced by property sets
				Dictionary<string, IfdBase> mapEntities = new Dictionary<string, IfdBase>();


				// core schema
				foreach (DocSection docSection in docProject.Sections)
				{
					foreach (DocSchema docSchema in docSection.Schemas)
					{
						// only export objects that have associated property sets
						foreach (DocPropertySet docPset in docSchema.PropertySets)
						{
							IfdBase ifdPset = CreateConcept(baseurl, sessionid, docPset, docPset.Name, docPset.Name, docPset.PropertySetType.ToString(), IfdConceptTypeEnum.BAG);
							foreach (DocProperty docProp in docPset.Properties)
							{
								IfdBase ifdProp = CreateConcept(baseurl, sessionid, docProp, docProp.Name, docProp.Name, docProp.PropertyType.ToString(), IfdConceptTypeEnum.PROPERTY);
								if (ifdProp != null)
								{
									CreateRelationship(baseurl, sessionid, ifdPset.guid, ifdProp.guid, IfdRelationshipTypeEnum.COLLECTS);

									string paramval = docProp.PrimaryDataType;
									if (!String.IsNullOrEmpty(paramval))
									{
										DocDefinition docDef = docProject.GetDefinition(paramval);
										if (docDef != null)
										{
											// get the measure type
											IfdBase ifdType = SearchConcept(baseurl, sessionid, docDef.Name, IfdConceptTypeEnum.MEASURE);
											if (ifdType == null)
											{
												// create concept
												ifdType = CreateConcept(baseurl, sessionid, docDef, docDef.Name, docDef.Name, null, IfdConceptTypeEnum.MEASURE);

												// for enums, get enumerated type
												if (docProp.PropertyType == DocPropertyTemplateTypeEnum.P_ENUMERATEDVALUE)
												{
													DocSchema docPropSchema = null;
													DocPropertyEnumeration docPropEnum = docProject.FindPropertyEnumeration(docProp.SecondaryDataType, out docPropSchema);
													if (docPropEnum != null)
													{
														foreach (DocPropertyConstant docPropConst in docPropEnum.Constants)
														{
															IfdBase ifdConst = CreateConcept(baseurl, sessionid, docPropConst, docPropConst.Name, docPropConst.Name, null, IfdConceptTypeEnum.VALUE);
															CreateRelationship(baseurl, sessionid, ifdType.guid, ifdConst.guid, IfdRelationshipTypeEnum.ASSIGNS_VALUES);
														}
													}
												}
											}
											CreateRelationship(baseurl, sessionid, ifdProp.guid, ifdType.guid, IfdRelationshipTypeEnum.ASSIGNS_MEASURES); // ??? fails for Pset_BuildingUse.NarrativeText / IfcText
										}
									}
								}
							}

							// now link the property set to applicable type
							DocEntity[] docEntities = docPset.GetApplicableTypeDefinitions(docProject);
							if (docEntities != null && docEntities.Length > 0)
							{
								// only the first one matters
								DocEntity docEnt = docEntities[0];
								IfdBase ifdEnt = null;
								if (!mapEntities.TryGetValue(docEnt.Name, out ifdEnt))
								{
									ifdEnt = CreateConcept(baseurl, sessionid, docEnt, docEnt.Name, docEnt.Name, null, IfdConceptTypeEnum.SUBJECT);
									mapEntities.Add(docEnt.Name, ifdEnt);

									// subtypes (predefined type)
									foreach (DocAttribute docAttr in docEnt.Attributes)
									{
										if (docAttr.Name.Equals("PredefinedType"))
										{
											DocEnumeration docEnum = docProject.GetDefinition(docAttr.DefinedType) as DocEnumeration;
											if (docEnum != null)
											{
												foreach (DocConstant docConst in docEnum.Constants)
												{
													IfdBase ifdConst = CreateConcept(baseurl, sessionid, docConst, docConst.Name, docConst.Name, null, IfdConceptTypeEnum.SUBJECT);
													CreateRelationship(baseurl, sessionid, ifdEnt.guid, ifdConst.guid, IfdRelationshipTypeEnum.SPECIALIZES);
												}
											}
										}
									}
								}
								CreateRelationship(baseurl, sessionid, ifdEnt.guid, ifdPset.guid, IfdRelationshipTypeEnum.ASSIGNS_COLLECTIONS); //!!! Fails with Forbidden!!! why???
																																				// http://test.bsdd.buildingsmart.org/api/4.0/IfdRelationship/validrelations/SUBJECT/BAG indicates 
																																				// <ifdRelationshipTypeEnums>
																																				//   <IfdRelationshipType xmlns="http://peregrine.catenda.no/objects">ASSIGNS_COLLECTIONS</IfdRelationshipType>
																																				// </ifdRelationshipTypeEnums>
							}
						}

						foreach (DocQuantitySet docPset in docSchema.QuantitySets)
						{
							IfdBase ifdPset = CreateConcept(baseurl, sessionid, docPset, docPset.Name, docPset.Name, "QTO_OCCURRENCEDRIVEN", IfdConceptTypeEnum.BAG);
							foreach (DocQuantity docProp in docPset.Quantities)
							{
								IfdBase ifdProp = CreateConcept(baseurl, sessionid, docProp, docProp.Name, docProp.Name, docProp.QuantityType.ToString(), IfdConceptTypeEnum.PROPERTY);
								if (ifdProp != null)
								{
									CreateRelationship(baseurl, sessionid, ifdPset.guid, ifdProp.guid, IfdRelationshipTypeEnum.COLLECTS);

									string propclass = "IfcQuantityCount";
									switch (docProp.QuantityType)
									{
										case DocQuantityTemplateTypeEnum.Q_AREA:
											propclass = "IfcQuantityArea";
											break;

										case DocQuantityTemplateTypeEnum.Q_COUNT:
											propclass = "IfcQuantityCount";
											break;

										case DocQuantityTemplateTypeEnum.Q_LENGTH:
											propclass = "IfcQuantityLength";
											break;

										case DocQuantityTemplateTypeEnum.Q_TIME:
											propclass = "IfcQuantityTime";
											break;

										case DocQuantityTemplateTypeEnum.Q_VOLUME:
											propclass = "IfcQuantityVolume";
											break;

										case DocQuantityTemplateTypeEnum.Q_WEIGHT:
											propclass = "IfcQuantityWeight";
											break;
									}

									string paramval = propclass;
									if (!String.IsNullOrEmpty(paramval))
									{
										DocDefinition docDef = docProject.GetDefinition(paramval);
										if (docDef != null)
										{
											// get the measure type
											IfdBase ifdType = SearchConcept(baseurl, sessionid, docDef.Name, IfdConceptTypeEnum.MEASURE);
											if (ifdType == null)
											{
												// create concept
												ifdType = CreateConcept(baseurl, sessionid, docDef, docDef.Name, docDef.Name, null, IfdConceptTypeEnum.MEASURE);
											}
											CreateRelationship(baseurl, sessionid, ifdProp.guid, ifdType.guid, IfdRelationshipTypeEnum.ASSIGNS_MEASURES); // ??? fails for Pset_BuildingUse.NarrativeText / IfcText
										}
									}
								}
							}

							// now link the property set to applicable type
							DocEntity[] docEntities = docPset.GetApplicableTypeDefinitions(docProject);
							if (docEntities != null && docEntities.Length > 0)
							{
								// only the first one matters
								DocEntity docEnt = docEntities[0];
								IfdBase ifdEnt = null;
								if (mapEntities.TryGetValue(docEnt.Name, out ifdEnt))
								{
									CreateRelationship(baseurl, sessionid, ifdEnt.guid, ifdPset.guid, IfdRelationshipTypeEnum.ASSIGNS_COLLECTIONS);
								}
							}

						}
					}
				}
			}
		}

		public static void UploadTemplateUsage(DocProject docProject, string baseurl, string sessionid, string parentid, DocTemplateUsage docConc)
		{
			// MVD Concept entry is a relationship in BSDD; contexts are exchanges
			foreach (DocTemplateItem docItem in docConc.Items)
			{
				if (docItem.Concepts.Count == 0)
				{
					string code = docItem.GetParameterValue("Reference");
					if (String.IsNullOrEmpty(code))
					{
						code = docItem.Name;
					}
					code = HttpUtility.UrlEncode(code);

					string name = docItem.GetParameterValue("Name");
					if (code != null && name != null)
					{
						// if no sub-concepts, then its a property
						IfdBase ifdItem = CreateConcept(baseurl, sessionid, docItem, code, name, null, IfdConceptTypeEnum.PROPERTY);
						CreateRelationship(baseurl, sessionid, parentid, ifdItem.guid, IfdRelationshipTypeEnum.ASSIGNS_PROPERTIES);

						string paramval = docItem.GetParameterValue("Value");
						if (!String.IsNullOrEmpty(paramval))
						{
							DocDefinition docDef = docProject.GetDefinition(paramval);
							if (docDef != null)
							{
								// get the measure type
								IfdBase ifdType = SearchConcept(baseurl, sessionid, docDef.Name, IfdConceptTypeEnum.MEASURE);
								if (ifdType == null)
								{
									// create concept
									ifdType = CreateConcept(baseurl, sessionid, docDef, docDef.Name, docDef.Name, null, IfdConceptTypeEnum.MEASURE);
								}
								CreateRelationship(baseurl, sessionid, ifdItem.guid, ifdType.guid, IfdRelationshipTypeEnum.ASSIGNS_MEASURES);
							}
						}
					}
				}
				else
				{
					// otherwise its a nest
					if (docItem.Name != null)
					{
						IfdBase ifdItem = CreateConcept(baseurl, sessionid, docItem, docItem.Name, docItem.Name, null, IfdConceptTypeEnum.NEST);
						CreateRelationship(baseurl, sessionid, parentid, ifdItem.guid, IfdRelationshipTypeEnum.ASSIGNS_COLLECTIONS);

						// recurse -- e.g. properties within property sets
						foreach (DocTemplateUsage docInner in docItem.Concepts)
						{
							UploadTemplateUsage(docProject, baseurl, sessionid, ifdItem.guid, docInner);
						}
					}
				}
			}

		}

		public static string LanguageEN = "3vvsOOoT0Hsm00051Mm008";
		public static string LanguageID = "1ASQw0qJqHuO00025QrE$V";

		public static IfdName CreateName(string baseurl, string sessionid, string langid, string name)
		{
			try
			{

				string url = baseurl + "api/4.0/IfdName?languageGuid=" + langid + "&name=" + name + "&nameType=FULLNAME";
				HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
				request.Method = "POST";
				request.ContentType = "application/x-www-form-urlencoded";
				request.ContentLength = 0;
				request.Accept = "application/json";
				request.Headers.Add("cookie", "peregrineapisessionid=" + sessionid);
				HttpWebResponse response = (HttpWebResponse)request.GetResponse();
				Stream stream = response.GetResponseStream();

				DataContractJsonSerializerSettings settings = new DataContractJsonSerializerSettings();
				DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(IfdName));
				IfdName ifdRoot = (IfdName)ser.ReadObject(stream);
				return ifdRoot;
			}
			catch (Exception xx)
			{
				System.Diagnostics.Debug.WriteLine(xx.Message);
			}

			return null;
		}

		public static IfdBase CreateDescription(string baseurl, string sessionid, string langid, string desc)
		{
			try
			{
				string url = baseurl + "api/4.0/IfdDescription?languageGuid=" + langid + "&description=" + desc + "&descriptionType=DEFINITION";
				HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
				request.Method = "POST";
				request.ContentType = "application/x-www-form-urlencoded";
				request.ContentLength = 0;
				request.Accept = "application/json";
				request.Headers.Add("cookie", "peregrineapisessionid=" + sessionid);
				HttpWebResponse response = (HttpWebResponse)request.GetResponse();
				Stream stream = response.GetResponseStream();

				DataContractJsonSerializerSettings settings = new DataContractJsonSerializerSettings();
				DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(IfdBase));
				IfdBase ifdRoot = (IfdBase)ser.ReadObject(stream);
				return ifdRoot;
			}
			catch (Exception xx)
			{
				System.Diagnostics.Debug.WriteLine(xx.Message);
			}

			return null;
		}

		/// <summary>
		/// Finds an existing item by IFC identifier
		/// </summary>
		/// <param name="baseurl"></param>
		/// <param name="sessionid"></param>
		/// <param name="identifier"></param>
		/// <returns></returns>
		public static IfdConcept SearchConcept(string baseurl, string sessionid, string identifier, IfdConceptTypeEnum type)
		{
			try
			{
				string url = baseurl + "api/4.0/IfdConcept/search/filter/language/" + LanguageID + "/type/" + type.ToString() + "/" + identifier;
				HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
				request.Method = "GET";
				request.ContentType = "application/x-www-form-urlencoded";
				request.ContentLength = 0;
				request.Accept = "application/json";
				request.Headers.Add("cookie", "peregrineapisessionid=" + sessionid);
				HttpWebResponse response = (HttpWebResponse)request.GetResponse();
				Stream stream = response.GetResponseStream();

				DataContractJsonSerializerSettings settings = new DataContractJsonSerializerSettings();
				DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(ResponseSearch));
				ResponseSearch search = (ResponseSearch)ser.ReadObject(stream);
				if (search != null && search.IfdConcept != null && search.IfdConcept.Length > 0)
					return search.IfdConcept[0];
			}
			catch (Exception xx)
			{
				System.Diagnostics.Debug.WriteLine(xx.Message);
			}

			return null;
		}

		/// <summary>
		/// Maps locale to bsDD guid.
		/// </summary>
		/// <param name="locale"></param>
		/// <returns>Language ID if it exists, or null.</returns>
		private static string GetLanguageId(string locale)
		{
			if (locale == null)
				return null;

			string major = locale.Substring(0, 2).ToLower();
			switch (major)
			{
				case "en":
					return "3vvsOOoT0Hsm00051Mm008";

				case "zn":
				case "zh":
					return "1WfhO0obaHsm00W01W3_W0";

				case "it":
					return "1WfhOAobaHsm00W01W3_W0";

				case "ru":
					return "1WfhOKobaHsm00W01W3_W0";

				case "ko":
				case "kr":
					return "1WfhOoobaHsm00W01W3_W0";

				case "es":
					return "2Ym1xvKZb4sfGlIwkz49rS";

				case "de":
					return "3vvsOYoT0Hsm00051Mm008";

				case "nn":
					return "3vvsOEoT0Hsm00051Mm008";

				case "fr":
					return "3vvsOsoT0Hsm00051Mm008";

				case "ja":
					return "3vvsPyoT0Hsm00051Mm008";
			}

			return null;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="baseurl">URL of server</param>
		/// <param name="sessionid">identifies server session</param>
		/// <param name="docObject">object to be published</param>
		/// <param name="identifier">identifier to use for IFC name</param>
		/// <param name="name">identifier to use for English name</param>
		/// <param name="type">identifier to use for IFC property type encoding, which is stored within description of IFC language</param>
		/// <param name="conctype">type of concept</param>
		/// <returns>guid of new concept</returns>
		public static IfdBase CreateConcept(string baseurl, string sessionid, DocObject docObject, string identifier, string name, string type, IfdConceptTypeEnum conctype)
		{
			System.Diagnostics.Debug.WriteLine(DateTime.Now + " " + conctype.ToString() + " " + identifier + " START");

			List<IfdName> listNames = new List<IfdName>();
			List<IfdBase> listDescs = new List<IfdBase>();

			// create name for IFC
			IfdName ifdNameIFC = CreateName(baseurl, sessionid, LanguageID, identifier);
			if (ifdNameIFC == null)
				return null;

			listNames.Add(ifdNameIFC);

			// create type identifier if indicated
			if (!String.IsNullOrEmpty(type))
			{
				string desc = HttpUtility.UrlEncode(type);
				IfdBase ifdDescID = CreateDescription(baseurl, sessionid, LanguageID, desc);
				if (ifdDescID == null)
					return null;

				listDescs.Add(ifdDescID);
			}

			// localization
			bool hasEnglishName = false;
			bool hasEnglishDesc = false;
			foreach (DocLocalization docLoc in docObject.Localization)
			{
				// look up language id
				string langid = GetLanguageId(docLoc.Locale);
				if (langid != null)
				{
					if (!String.IsNullOrEmpty(docLoc.Name))
					{
						string locname = HttpUtility.UrlEncode(docLoc.Name);
						IfdName ifdName = CreateName(baseurl, sessionid, langid, locname);
						if (ifdName == null)
							return null;

						listNames.Add(ifdName);

						if (langid == LanguageEN)
						{
							hasEnglishName = true;
						}
					}

					if (!String.IsNullOrEmpty(docLoc.Documentation))
					{
						string locdesc = HttpUtility.UrlEncode(docLoc.Documentation);
						IfdBase ifdDesc = CreateDescription(baseurl, sessionid, langid, locdesc);
						if (ifdDesc == null)
							return null;

						listDescs.Add(ifdDesc);

						if (langid == LanguageEN)
						{
							hasEnglishDesc = true;
						}
					}
				}
			}

			if (!hasEnglishName && !String.IsNullOrEmpty(name))
			{
				// add default english name
				IfdName ifdNameEN = CreateName(baseurl, sessionid, LanguageEN, name);
				if (ifdNameEN == null)
					return null;

				listNames.Add(ifdNameEN);
			}

			if (!hasEnglishDesc && !String.IsNullOrEmpty(docObject.Documentation))
			{
				string desc = HttpUtility.UrlEncode(docObject.Documentation);
				IfdBase ifdDescEN = CreateDescription(baseurl, sessionid, LanguageEN, desc);
				if (ifdDescEN == null)
					return null;

				listDescs.Add(ifdDescEN);
			}

			// create concept
			StringBuilder sb = new StringBuilder();

			sb.Append(baseurl);
			sb.Append("api/4.0/IfdConcept?fullNameGuids=");
			for (int i = 0; i < listNames.Count; i++)
			{
				if (i != 0)
				{
					sb.Append(",");
				}
				sb.Append(listNames[i].guid);
			}
			sb.Append("&conceptType=");
			sb.Append(conctype.ToString());

			if (listDescs.Count > 0)
			{
				sb.Append("&definitionGuids=");
				for (int i = 0; i < listDescs.Count; i++)
				{
					if (i != 0)
					{
						sb.Append(",");
					}
					sb.Append(listDescs[i].guid);
				}
			}

			string url = sb.ToString();

			HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
			request.Method = "POST";
			request.ContentType = "application/x-www-form-urlencoded";
			request.ContentLength = 0;
			request.Accept = "application/json";
			request.Headers.Add("cookie", "peregrineapisessionid=" + sessionid);
			HttpWebResponse response = (HttpWebResponse)request.GetResponse();
			Stream stream = response.GetResponseStream();

			DataContractJsonSerializerSettings settings = new DataContractJsonSerializerSettings();
			DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(IfdBase));
			IfdBase ifdRoot = (IfdBase)ser.ReadObject(stream);

			// record the ID on the doc object
			docObject.RegisterDictionary(baseurl, ifdRoot.guid);

			System.Diagnostics.Debug.WriteLine(DateTime.Now + " " + conctype.ToString() + " " + identifier + " FINISH");

			return ifdRoot;
		}

		public static void CreateRelationship(string baseurl, string sessionid, string idParent, string idChild, IfdRelationshipTypeEnum reltype)
		{
			//// requires admin access: string url = baseurl + "api/4.0/IfdRelationship?relationshipType=" + reltype + "&parentGuid=" + idParent + "&childGuid=" + idChild; // contextGuids=,
			string url = baseurl + "api/4.0/IfdConcept/" + idParent + "/child?childGuid=" + idChild + "&relationshipType=" + reltype; // context guids???
			HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
			request.Method = "POST";
			request.ContentType = "application/x-www-form-urlencoded";
			request.ContentLength = 0;
			request.Accept = "application/json";
			request.Headers.Add("cookie", "peregrineapisessionid=" + sessionid);

			try
			{
				HttpWebResponse response = (HttpWebResponse)request.GetResponse();
			}
			catch (Exception xx)
			{
				System.Diagnostics.Debug.WriteLine(xx.Message);
			}

		}
	}

	[DataContract]
	public class ResponseContext
	{
		[DataMember] public IfdContext[] IfdContext;
	}

	[DataContract]
	public class ResponseSearch
	{
		[DataMember] public IfdConcept[] IfdConcept;
	}

	[DataContract]
	public class ResponseConceptInRelationship
	{
		[DataMember] public IfdConceptInRelationship[] IfdConceptInRelationship;
	}

	[DataContract]
	public class IfdConceptInRelationship : IfdConcept
	{
	}

	[DataContract]
	public class IfdBase
	{
		[DataMember(Order = 0)] public string guid;
	}

	[DataContract]
	public class IfdContext : IfdBase
	{
		[DataMember(Order = 0)] public IfdName[] fullNames;
		[DataMember(Order = 1)] public IfdDescription[] definitions;
		[DataMember(Order = 2)] public string status;
		[DataMember(Order = 3)] public string versionDate;
		[DataMember(Order = 4)] public string versionId;
		[DataMember(Order = 5)] public bool readOnly;
		[DataMember(Order = 6)] public bool restricted;
	}

	[DataContract]
	public class IfdConcept : IfdBase
	{
		[DataMember(Order = 0)] public string versionId;
		[DataMember(Order = 1)] public string versionDate;
		[DataMember(Order = 2)] public string status;
		[DataMember(Order = 3)] public IfdName[] fullNames;
		[DataMember(Order = 4)] public IfdDescription definitions;
		[DataMember(Order = 5)] public IfdDescription comments;
		[DataMember(Order = 6)] public string conceptType;
		[DataMember(Order = 7)] public IfdName[] shortNames;
		[DataMember(Order = 8)] public IfdName[] lexemes;
		[DataMember(Order = 9)] public IfdIllustration[] illustrations;
		[DataMember(Order = 10)] public IfdOrganization owner;

		public override string ToString()
		{
			foreach (IfdName ifdName in this.fullNames)
			{
				if (ifdName.languageFamily == "IFC")
				{
					return ifdName.name;
				}
			}

			foreach (IfdName ifdName in this.fullNames)
			{
				if (ifdName.language.languageCode == "en")
				{
					return ifdName.name;
				}
			}

			return this.guid;
		}
	}

	[DataContract]
	public class IfdIllustration : IfdLanguageRepresentationBase
	{
		[DataMember(Order = 0)] public string blobstoreKey;
		[DataMember(Order = 1)] public string illustrationUrl;
	}

	[DataContract]
	public class IfdOrganization
	{
		[DataMember(Order = 0)] public string guid;
		[DataMember(Order = 1)] public string name;
		[DataMember(Order = 2)] public string url;
	}

	public enum IfdConceptTypeEnum
	{
		NULL = 0,
		ACTOR = 1,
		ACTIVITY = 2,
		DOCUMENT = 3,
		PROPERTY = 4,
		SUBJECT = 5,
		UNIT = 6,
		MEASURE = 7,
		VALUE = 8,
		NEST = 9,
		BAG = 10,
		CLASSIFICATION = 11,
		UNDEFINED = -1,
	}

	public enum IfdRelationshipTypeEnum
	{
		NULL = 0,
		COLLECTS = 1,
		ASSIGNS_COLLECTIONS = 2,
		ASSOCIATES = 3,
		COMPOSES = 4,
		GROUPS = 5,
		SPECIALIZES = 6,
		ACTS_UPON = 7,
		SEQUENCES = 8,
		DOCUMENTS = 9,
		CLASSIFIES = 10,
		ASSIGNS_MEASURES = 11,
		ASSIGNS_PROPERTIES = 12,
		ASSIGNS_UNITS = 13,
		ASSIGNS_VALUES = 14,
		ASSIGNS_PROPERTY_WITH_VALUES = 15,
		UNDEFINED = -1,
	}

	[DataContract]
	public abstract class IfdLanguageRepresentationBase
	{
		[DataMember(Order = 0)] public string guid;
		[DataMember(Order = 1)] public IfdLanguage language;
		[DataMember(Order = 2)] public string languageFamily;

	}

	[DataContract]
	public class IfdName : IfdLanguageRepresentationBase
	{
		[DataMember(Order = 3)] public string name;
		[DataMember(Order = 4)] public string nameType;
	}

	[DataContract]
	public class IfdDescription : IfdLanguageRepresentationBase
	{
		[DataMember(Order = 3)] public string description;
		[DataMember(Order = 4)] public string descriptionType; // enum...
	}

	public enum IfdDescriptionTypeEnum
	{
		NULL = 0,
		DEFINITION = 1,
		COMMENT = 2,
		UNDEFINED = -1,
	}

	[DataContract]
	public class IfdLanguage
	{
		[DataMember(Order = 0)] public string guid;
		[DataMember(Order = 1)] public string nameInEnglish;
		[DataMember(Order = 2)] public string nameInSelf;
		[DataMember(Order = 3)] public string languageCode;
	}

	// 2018-01-05 Meeting Notes: don't encode property type in IFC description, but use type relationship with IfcPropertySingleValue, etc.
	// Enclose entities within schema
	// Enclose schema within IFC top node

	// Reference Value / Time Series
	// Table Value
	// List Value
	// Complex Value
}