public List <BaseUsage> GetSimpleChildrens(BaseUsage usage)
{
using (IUnitOfWork unitOfWork = this.GetUnitOfWork())
{
List <BaseUsage> temp = new List <BaseUsage>();
if (usage is MetadataPackageUsage)
{
MetadataPackageUsage mpu = (MetadataPackageUsage)usage;
var mauRepo = unitOfWork.GetReadOnlyRepository <MetadataAttributeUsage>();
foreach (MetadataAttributeUsage childUsage in mpu.MetadataPackage.MetadataAttributeUsages)
{
if (IsSimple(childUsage))
{
mauRepo.LoadIfNot(childUsage.MetadataAttribute);
temp.Add(childUsage);
}
}
}
if (usage is MetadataAttributeUsage)
{
MetadataAttributeUsage mau = (MetadataAttributeUsage)usage;
if (mau.MetadataAttribute.Self is MetadataCompoundAttribute)
{
var mnauRepo = unitOfWork.GetReadOnlyRepository <MetadataNestedAttributeUsage>();
foreach (MetadataNestedAttributeUsage childUsage in ((MetadataCompoundAttribute)mau.MetadataAttribute.Self).MetadataNestedAttributeUsages)
{
if (IsSimple(childUsage))
{
mnauRepo.LoadIfNot(childUsage.Member);
temp.Add(childUsage);
}
}
}
}
if (usage is MetadataNestedAttributeUsage)
{
MetadataNestedAttributeUsage mnau = (MetadataNestedAttributeUsage)usage;
if (mnau.Member.Self is MetadataCompoundAttribute)
{
var mnauRepo = unitOfWork.GetReadOnlyRepository <MetadataNestedAttributeUsage>();
foreach (MetadataNestedAttributeUsage childUsage in ((MetadataCompoundAttribute)mnau.Member.Self).MetadataNestedAttributeUsages)
{
if (IsSimple(childUsage))
{
mnauRepo.LoadIfNot(childUsage.Member);
temp.Add(childUsage);
}
}
}
}
return(temp);
}
}
public void RemoveMetadataPackageUsage(MetadataPackageUsage usage)
{
Contract.Requires(usage != null && usage.Id >= 0);
using (IUnitOfWork uow = this.GetUnitOfWork())
{
IRepository <MetadataPackageUsage> repo = uow.GetRepository <MetadataPackageUsage>();
repo.Delete(usage);
uow.Commit();
}
}
public List <BaseUsage> GetChildren(long usageId, Type type)
{
using (IUnitOfWork unitOfWork = this.GetUnitOfWork())
{
List <BaseUsage> temp = new List <BaseUsage>();
if (type.Equals(typeof(MetadataPackageUsage)))
{
MetadataPackageUsage mpu = unitOfWork.GetReadOnlyRepository <MetadataPackageUsage>().Get(usageId);
var mauRepo = unitOfWork.GetReadOnlyRepository <MetadataAttributeUsage>();
foreach (MetadataAttributeUsage childUsage in mpu.MetadataPackage.MetadataAttributeUsages)
{
mauRepo.LoadIfNot((childUsage).MetadataAttribute);
temp.Add(childUsage);
}
}
if (type.Equals(typeof(MetadataAttributeUsage)))
{
MetadataAttributeUsage mau = unitOfWork.GetReadOnlyRepository <MetadataAttributeUsage>().Get(usageId);
if (mau.MetadataAttribute.Self is MetadataCompoundAttribute)
{
var mnauRepo = unitOfWork.GetReadOnlyRepository <MetadataNestedAttributeUsage>();
foreach (MetadataNestedAttributeUsage childUsage in ((MetadataCompoundAttribute)mau.MetadataAttribute.Self).MetadataNestedAttributeUsages)
{
mnauRepo.LoadIfNot(childUsage.Member);
temp.Add(childUsage);
}
}
}
if (type.Equals(typeof(MetadataNestedAttributeUsage)))
{
MetadataNestedAttributeUsage mnau = unitOfWork.GetReadOnlyRepository <MetadataNestedAttributeUsage>().Get(usageId);
if (mnau.Member.Self is MetadataCompoundAttribute)
{
var mnauRepo = unitOfWork.GetReadOnlyRepository <MetadataNestedAttributeUsage>();
foreach (MetadataNestedAttributeUsage childUsage in ((MetadataCompoundAttribute)mnau.Member.Self).MetadataNestedAttributeUsages)
{
temp.Add(childUsage);
}
}
}
return(temp);
}
}
public bool HasUsagesWithSimpleType(long usageId, Type type)
{
BaseUsage usage = loadUsage(usageId, type);
if (type.Equals(typeof(MetadataPackageUsage)))
{
MetadataPackageUsage mpu = this.GetUnitOfWork().GetReadOnlyRepository <MetadataPackageUsage>().Get(usageId);
foreach (BaseUsage childUsage in mpu.MetadataPackage.MetadataAttributeUsages)
{
if (IsSimple(childUsage))
{
return(true);
}
}
}
if (type.Equals(typeof(MetadataAttributeUsage)))
{
MetadataAttributeUsage mau = this.GetUnitOfWork().GetReadOnlyRepository <MetadataAttributeUsage>().Get(usageId);;
if (mau.MetadataAttribute.Self is MetadataCompoundAttribute)
{
foreach (BaseUsage childUsage in ((MetadataCompoundAttribute)mau.MetadataAttribute.Self).MetadataNestedAttributeUsages)
{
if (IsSimple(childUsage))
{
return(true);
}
}
}
}
if (type.Equals(typeof(MetadataNestedAttributeUsage)))
{
MetadataNestedAttributeUsage mnau = (MetadataNestedAttributeUsage)usage;
if (mnau.Member.Self is MetadataCompoundAttribute)
{
foreach (BaseUsage childUsage in ((MetadataCompoundAttribute)mnau.Member.Self).MetadataNestedAttributeUsages)
{
if (IsSimple(childUsage))
{
return(true);
}
}
}
}
return(false);
}
private static List <LinkElementModel> getChildrenFromMetadataPackageUsage(LinkElementModel model)
{
MetadataStructureManager msm = new MetadataStructureManager();
try
{
MetadataPackageUsage metadataPackageUsage = msm.PackageUsageRepo.Get(model.ElementId);
return(getChildrenFromMetadataPackage(metadataPackageUsage.MetadataPackage.Id, model.Position));
}
finally
{
msm.Dispose();
}
}
public bool HasRequiredSimpleTypes(BaseUsage usage)
{
if (usage is MetadataPackageUsage)
{
MetadataPackageUsage mpu = (MetadataPackageUsage)usage;
foreach (BaseUsage childUsage in mpu.MetadataPackage.MetadataAttributeUsages)
{
if (IsSimple(childUsage) && childUsage.MinCardinality > 0)
{
return(true);
}
}
}
if (usage is MetadataAttributeUsage)
{
MetadataAttributeUsage mau = (MetadataAttributeUsage)usage;
if (mau.MetadataAttribute.Self is MetadataCompoundAttribute)
{
foreach (BaseUsage childUsage in ((MetadataCompoundAttribute)mau.MetadataAttribute.Self).MetadataNestedAttributeUsages)
{
if (IsSimple(childUsage) && childUsage.MinCardinality > 0)
{
return(true);
}
}
}
}
if (usage is MetadataNestedAttributeUsage)
{
MetadataNestedAttributeUsage mnau = (MetadataNestedAttributeUsage)usage;
if (mnau.Member.Self is MetadataCompoundAttribute)
{
foreach (BaseUsage childUsage in ((MetadataCompoundAttribute)mnau.Member.Self).MetadataNestedAttributeUsages)
{
if (IsSimple(childUsage) && childUsage.MinCardinality > 0)
{
return(true);
}
}
}
}
return(false);
}
public MetadataPackageUsage AddMetadataPackageUsage(MDS.MetadataStructure structure, MetadataPackage package, string label, string description, int minCardinality, int maxCardinality, XmlDocument extra = null)
{
Contract.Requires(package != null && package.Id >= 0);
Contract.Requires(structure != null && structure.Id >= 0);
Contract.Ensures(Contract.Result <MetadataPackageUsage>() != null && Contract.Result <MetadataPackageUsage>().Id >= 0);
using (IUnitOfWork uow = this.GetUnitOfWork())
{
IRepository <MetadataPackageUsage> repo = uow.GetRepository <MetadataPackageUsage>();
IRepository <MDS.MetadataStructure> repo2 = uow.GetRepository <MDS.MetadataStructure>();
repo2.Reload(structure);
repo2.LoadIfNot(structure.MetadataPackageUsages);
int count = 0;
try
{
count = (from v in structure.MetadataPackageUsages
where v.MetadataPackage.Id.Equals(package.Id)
select v
)
.Count();
}
catch { }
MetadataPackageUsage usage = new MetadataPackageUsage()
{
MetadataPackage = package,
MetadataStructure = structure,
// if no label is provided, use the package name and a sequence number calculated by the number of occurrences of that package in the current structure
Label = !string.IsNullOrWhiteSpace(label) ? label : (count <= 0 ? package.Name : string.Format("{0} ({1})", package.Name, count)),
Description = description,
MinCardinality = minCardinality,
MaxCardinality = maxCardinality,
Extra = extra
};
structure.MetadataPackageUsages.Add(usage);
package.UsedIn.Add(usage);
repo.Put(usage);
uow.Commit();
return(usage);
}
}
public static MetadataPackageModel CreateMetadataPackageModel(BaseUsage mPUsage, int number)
{
MetadataPackageUsage metadataPackageUsage = (MetadataPackageUsage)mPUsage;
if (metadataPackageUsage != null)
{
return(new MetadataPackageModel
{
Source = metadataPackageUsage,
Number = number,
MetadataAttributeModels = new List <MetadataAttributeModel>(),
DisplayName = metadataPackageUsage.Label,
Discription = metadataPackageUsage.Description,
MinCardinality = metadataPackageUsage.MinCardinality,
MaxCardinality = metadataPackageUsage.MaxCardinality
});
}
else
{
return(null);
}
}
public long GetIdOfType(BaseUsage usage)
{
if (usage is MetadataPackageUsage)
{
MetadataPackageUsage mpu = (MetadataPackageUsage)usage;
return(mpu.MetadataPackage.Id);
}
if (usage is MetadataAttributeUsage)
{
MetadataAttributeUsage mau = (MetadataAttributeUsage)usage;
return(mau.MetadataAttribute.Id);
}
if (usage is MetadataNestedAttributeUsage)
{
MetadataNestedAttributeUsage mnau = (MetadataNestedAttributeUsage)usage;
return(mnau.Member.Id);
}
return(0);
}
public string GetNameOfType(BaseUsage usage)
{
if (usage is MetadataPackageUsage)
{
MetadataPackageUsage mpu = (MetadataPackageUsage)usage;
return(mpu.MetadataPackage.Name);
}
if (usage is MetadataAttributeUsage)
{
MetadataAttributeUsage mau = (MetadataAttributeUsage)usage;
return(mau.MetadataAttribute.Name);
}
if (usage is MetadataNestedAttributeUsage)
{
MetadataNestedAttributeUsage mnau = (MetadataNestedAttributeUsage)usage;
return(mnau.Member.Name);
}
return("");
}
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);
}
public void ConvertMetadataAttributeModels(BaseUsage source, long metadataStructureId, int 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 (UsageHelper.IsSimple(usage))
// {
// MetadataAttributeModels.Add(MetadataAttributeModel.Convert(usage, mau, metadataStructureId, Number));
// }
// }
// }
// }
//}
//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 (UsageHelper.IsSimple(usage))
// {
// MetadataAttributeModels.Add(MetadataAttributeModel.Convert(usage, mnau, metadataStructureId, Number));
// }
// }
// }
// }
//}
if (Source is MetadataPackageUsage)
{
MetadataPackageUsage mpu = (MetadataPackageUsage)Source;
if (mpu.MetadataPackage is MetadataPackage)
{
MetadataPackage mp = mpu.MetadataPackage;
if (mp != null)
{
foreach (MetadataAttributeUsage usage in mp.MetadataAttributeUsages)
{
if (metadataStructureUsageHelper.IsSimple(usage))
{
MetadataAttributeModels.Add(FormHelper.CreateMetadataAttributeModel(usage, mpu, metadataStructureId, Number, stepId));
}
}
}
}
}
}
