/// <summary>
/// Persists a compound metadata attribute in the database
/// </summary>
/// <param name="entity">is an unsaved compound metadata data attribute</param>
/// <returns>The saved compound metadata attribute</returns>
/// <remarks>The attribute should have at least two other attributes as its member to be considered a compound! Also it should have at least a non empty short name.</remarks>
public MetadataCompoundAttribute Create(MetadataCompoundAttribute entity)
{
Contract.Requires(!string.IsNullOrWhiteSpace(entity.ShortName));
//Contract.Requires(entity.DataType != null && entity.DataType.Id >= 0);
//Contract.Requires(entity.Unit != null && entity.Unit.Id >= 0);
Contract.Requires(entity.MetadataNestedAttributeUsages != null && entity.MetadataNestedAttributeUsages.Count >= 2);
Contract.Ensures(Contract.Result <MetadataCompoundAttribute>() != null && Contract.Result <MetadataCompoundAttribute>().Id >= 0);
using (IUnitOfWork uow = this.GetUnitOfWork())
{
IRepository <MetadataCompoundAttribute> repo = uow.GetRepository <MetadataCompoundAttribute>();
repo.Put(entity);
uow.Commit();
}
return(entity);
}
public void ConvertMetadataAttributeModels(BaseUsage source, long metadataStructureId, long stepId)
{
Source = source;
if (Source is MetadataAttributeUsage)
{
MetadataAttributeUsage mau = (MetadataAttributeUsage)Source;
if (mau.MetadataAttribute.Self is MetadataCompoundAttribute)
{
MetadataCompoundAttribute mca = (MetadataCompoundAttribute)mau.MetadataAttribute.Self;
if (mca != null)
{
foreach (MetadataNestedAttributeUsage usage in mca.MetadataNestedAttributeUsages)
{
if (metadataStructureUsageHelper.IsSimple(usage))
{
MetadataAttributeModels.Add(FormHelper.CreateMetadataAttributeModel(usage, mau, metadataStructureId, Number, stepId));
}
}
}
}
}
if (Source is MetadataNestedAttributeUsage)
{
MetadataNestedAttributeUsage mnau = (MetadataNestedAttributeUsage)Source;
if (mnau.Member.Self is MetadataCompoundAttribute)
{
MetadataCompoundAttribute mca = (MetadataCompoundAttribute)mnau.Member.Self;
if (mca != null)
{
foreach (MetadataNestedAttributeUsage usage in mca.MetadataNestedAttributeUsages)
{
if (metadataStructureUsageHelper.IsSimple(usage))
{
MetadataAttributeModels.Add(FormHelper.CreateMetadataAttributeModel(usage, mnau, metadataStructureId, Number, stepId));
}
}
}
}
}
}
private static List <LinkElementModel> getChildrenFromComplexMetadataAttribute(long metadataCompountAttributeId, LinkElementPostion position)
{
List <LinkElementModel> tmp = new List <LinkElementModel>();
MetadataAttributeManager metadataAttributeManager = new MetadataAttributeManager();
try
{
MetadataCompoundAttribute mca = metadataAttributeManager.MetadataCompoundAttributeRepo.Get(metadataCompountAttributeId);
foreach (var attr in mca.MetadataNestedAttributeUsages)
{
LinkElementComplexity complexity = LinkElementComplexity.None;
LinkElementType type = LinkElementType.ComplexMetadataAttribute;
complexity = attr.Member.Self is MetadataSimpleAttribute
? LinkElementComplexity.Simple
: LinkElementComplexity.Complex;
//type = attr.Member.Self is MetadataSimpleAttribute
// ? LinkElementType.SimpleMetadataAttribute
// : LinkElementType.ComplexMetadataAttribute;
type = LinkElementType.MetadataNestedAttributeUsage;
tmp.Add(
new LinkElementModel(
0,
attr.Id,
type, attr.Label, "", position, complexity, attr.Description)
);
}
return(tmp);
}
finally
{
metadataAttributeManager.Dispose();
}
}
//Add Attribute to a package return a apackage
/// <summary>
///
/// </summary>
/// <remarks></remarks>
/// <seealso cref=""/>
/// <param name="package"></param>
/// <param name="attributeUsage"></param>
/// <param name="number"></param>
/// <returns></returns>
private XElement AddAttribute(XElement current, BaseUsage attributeUsage, int number)
{
string typeName = "";
string id = "";
string roleId = "";
List <MetadataNestedAttributeUsage> children = new List <MetadataNestedAttributeUsage>();
if (attributeUsage is MetadataAttributeUsage)
{
MetadataAttributeUsage metadataAttributeUsage = (MetadataAttributeUsage)attributeUsage;
typeName = metadataAttributeUsage.MetadataAttribute.Name;
id = metadataAttributeUsage.MetadataAttribute.Id.ToString();
roleId = metadataAttributeUsage.MetadataAttribute.Id.ToString();
}
else
{
MetadataNestedAttributeUsage mnau = (MetadataNestedAttributeUsage)attributeUsage;
typeName = mnau.Member.Name;
id = mnau.Member.Id.ToString();
roleId = mnau.Id.ToString();
if (mnau.Member.Self is MetadataCompoundAttribute)
{
MetadataCompoundAttribute mca = (MetadataCompoundAttribute)mnau.Member.Self;
children = mca.MetadataNestedAttributeUsages.ToList();
}
}
if (!Exist(typeName, number, current))
{
XElement role = Get(attributeUsage.Label, current);
if (role == null)
{
role = CreateXElement(attributeUsage.Label, XmlNodeType.MetadataAttributeUsage);
if (_mode.Equals(XmlNodeMode.xPath))
{
role.SetAttributeValue("name", attributeUsage.Label);
}
role.SetAttributeValue("id", attributeUsage.Id.ToString());
}
XElement element = CreateXElement(typeName, XmlNodeType.MetadataAttribute);
if (_mode.Equals(XmlNodeMode.xPath))
{
element.SetAttributeValue("name", typeName);
}
element.SetAttributeValue("roleId", roleId);
element.SetAttributeValue("id", id);
element.SetAttributeValue("number", number);
if (children.Count > 0)
{
foreach (BaseUsage baseUsage in children)
{
element = AddAttribute(element, baseUsage, 1);
}
}
role.Add(element);
current.Add(role);
}
else
{
throw new Exception("attribute exist");
}
return(current);
}
private XElement setChildren(XElement element, BaseUsage usage, XDocument importDocument = null)
{
MetadataAttribute metadataAttribute = null;
MetadataPackage metadataPackage = null;
if (usage is MetadataAttributeUsage)
{
MetadataAttributeUsage metadataAttributeUsage = (MetadataAttributeUsage)usage;
metadataAttribute = metadataAttributeUsage.MetadataAttribute;
}
else if (usage is MetadataNestedAttributeUsage)
{
MetadataNestedAttributeUsage mnau = (MetadataNestedAttributeUsage)usage;
metadataAttribute = mnau.Member;
}
else
{
MetadataPackageUsage mpu = (MetadataPackageUsage)usage;
metadataPackage = mpu.MetadataPackage;
}
if (metadataAttribute != null && metadataAttribute.Self is MetadataCompoundAttribute)
{
MetadataCompoundAttribute mca = this.GetUnitOfWork().GetReadOnlyRepository <MetadataCompoundAttribute>().Get(metadataAttribute.Self.Id);
foreach (MetadataNestedAttributeUsage nestedUsage in mca.MetadataNestedAttributeUsages)
{
if (importDocument != null)
{
string parentPath = element.GetAbsoluteXPathWithIndex();
string usagePath = parentPath + "/" + nestedUsage.Label;
XElement usageElement = importDocument.XPathSelectElement(usagePath);
List <XElement> typeList = new List <XElement>();
if (usageElement != null && usageElement.HasElements)
{
int num = usageElement.Elements().Count();
if (num == 0)
{
typeList = AddAndReturnAttribute(element, nestedUsage, 1, 1);
}
else
{
typeList = AddAndReturnAttribute(element, nestedUsage, 1, num);
}
}
else
{
Debug.WriteLine("NULL OR EMPTY:------> " + usagePath);
typeList = AddAndReturnAttribute(element, nestedUsage, 1, 1);
}
foreach (var type in typeList)
{
setChildren(type, nestedUsage, importDocument);
}
}
else
{
List <XElement> typeList = new List <XElement>();
typeList = AddAndReturnAttribute(element, nestedUsage, 1, 1);
setChildren(typeList.FirstOrDefault(), nestedUsage, importDocument);
}
}
}
else
{
if (metadataPackage != null)
{
foreach (MetadataAttributeUsage attrUsage in metadataPackage.MetadataAttributeUsages)
{
if (importDocument != null)
{
string parentPath = element.GetAbsoluteXPathWithIndex();
string usagePath = parentPath + "/" + attrUsage.Label;
XElement usageElement = importDocument.XPathSelectElement(usagePath);
List <XElement> typeList = new List <XElement>();
if (usageElement != null && usageElement.HasElements)
{
int num = usageElement.Elements().Count();
if (num == 0)
{
typeList = AddAndReturnAttribute(element, attrUsage, 1, 1);
}
else
{
typeList = AddAndReturnAttribute(element, attrUsage, 1, num);
}
}
else
{
Debug.WriteLine("NULL OR EMPTY:------> " + usagePath);
typeList = AddAndReturnAttribute(element, attrUsage, 1, 1);
}
foreach (var type in typeList)
{
setChildren(type, attrUsage, importDocument);
}
}
else
{
List <XElement> typeList = new List <XElement>();
typeList = AddAndReturnAttribute(element, attrUsage, 1, 1);
setChildren(typeList.FirstOrDefault(), attrUsage, importDocument);
}
}
}
}
return(element);
}
private XElement setChildren(XElement element, BaseUsage usage, XDocument importDocument = null)
{
MetadataAttribute metadataAttribute;
if (usage is MetadataAttributeUsage)
{
MetadataAttributeUsage metadataAttributeUsage = (MetadataAttributeUsage)usage;
metadataAttribute = metadataAttributeUsage.MetadataAttribute;
}
else
{
MetadataNestedAttributeUsage mnau = (MetadataNestedAttributeUsage)usage;
metadataAttribute = mnau.Member;
}
if (metadataAttribute.Self is MetadataCompoundAttribute)
{
//MetadataCompoundAttribute mca = (MetadataCompoundAttribute)metadataAttribute.Self;
MetadataCompoundAttribute mca = this.GetUnitOfWork().GetReadOnlyRepository <MetadataCompoundAttribute>().Get(metadataAttribute.Self.Id);
foreach (MetadataNestedAttributeUsage nestedUsage in mca.MetadataNestedAttributeUsages)
{
//Debug.WriteLine("MetadataCompoundAttribute: " + element.Name);
//Debug.WriteLine("*************************: " + element.Name);
//XElement x = element.Descendants().Where(e => e.Name.Equals(nestedUsage.Member.Name)).First();
if (importDocument != null)
{
string parentPath = element.GetAbsoluteXPathWithIndex();
string usagePath = parentPath + "/" + nestedUsage.Label;
//+"/"+ nestedUsage.Member.Name;
XElement usageElement = importDocument.XPathSelectElement(usagePath);
List <XElement> typeList = new List <XElement>();
if (usageElement != null && usageElement.HasElements)
{
int num = usageElement.Elements().Count();
//importDocument.XPathSelectElements(childPath).Count();
//num = XmlUtility.ToXmlDocument(importDocument).SelectNodes(childPath).Count;
if (num == 0)
{
typeList = AddAndReturnAttribute(element, nestedUsage, 1, 1);
//x = setChildren(x, nestedUsage, importDocument);
}
else
{
typeList = AddAndReturnAttribute(element, nestedUsage, 1, num);
}
}
else
{
Debug.WriteLine("NULL OR EMPTY:------> " + usagePath);
typeList = AddAndReturnAttribute(element, nestedUsage, 1, 1);
}
foreach (var type in typeList)
{
setChildren(type, nestedUsage, importDocument);
}
}
else
{
List <XElement> typeList = new List <XElement>();
typeList = AddAndReturnAttribute(element, nestedUsage, 1, 1);
setChildren(typeList.FirstOrDefault(), nestedUsage, importDocument);
}
}
}
return(element);
}
