public void OrderByDisplay(TaxonomyInfo taxonomy)
{
if (taxonomy == null)
{
return;
}
Dictionary <SchemaData, decimal[]> sds = (from si in taxonomy.SchemaInfos
let sd = si.SchemaData
where sd != null && (sd.NavigationOrder > 0 || sd.DisplayOrder > 0)
select sd).ToDictionary(
sd => sd, sd => new[] { sd.NavigationOrder, sd.DisplayOrder });
if (!sds.Any())
{
return;
}
//int iCtr = 0;
//foreach (SchemaData nav in
// (from sd in sds
// where sd.Value[0] > 0
// orderby sd.Value[0]
// select sd.Key).ToList())
//{
// sds[nav][0] = ++iCtr;
// if (sds[nav][1] > 0) sds[nav][1] = iCtr;
//}
decimal iCtr = 0;
foreach (SchemaData disp in
(from sd in sds
where sd.Value[1] > 0
orderby sd.Value[1]
select sd.Key).ToList())
{
if (sds[disp][0] > 0)
{
sds[disp][1] = iCtr = sds[disp][0];
}
else
{
sds[disp][1] = ++iCtr;
}
}
foreach (var kvp in sds)
{
SchemaInfo schemaInfo = kvp.Key.SchemaInfo;
SetValue(
schemaInfo.TaxonomyInfo, schemaInfo.Attribute, false, SchemaAttributeNavigationOrder, kvp.Value[0]);
SetValue(
schemaInfo.TaxonomyInfo, schemaInfo.Attribute, false, SchemaAttributeDisplayOrder, kvp.Value[1]);
}
}
public List <Sku> this[TaxonomyInfo index]
{
get
{
return
(SkuGroups.SelectMany(s => s.Sku.SkuInfos.Where(a => a.Active))
.Where(t => t.TaxonomyInfo == index)
.Select(s => s.Sku)
.ToList());
}
}
public static void UnmapNodeAttribute(TaxonomyInfo taxonomy, Attribute attribute)
{
SchemaInfo schemaInfo = taxonomy.SchemaInfos.FirstOrDefault(si => si.Attribute.Equals(attribute));
if (schemaInfo == null)
{
return;
}
schemaInfo.SchemaMetaInfos.SelectMany(smi => smi.SchemaMetaDatas).Where(md => md.Active).ForEach(
md => md.Active = false);
if (schemaInfo.SchemaData != null)
{
schemaInfo.SchemaData.Active = false;
}
}
public static int GetNodeCount(TaxonomyInfo taxonomy)
{
IEnumerable <TaxonomyInfo> childTaxonomyInfos;
int count = 0;
if (taxonomy != null)
{
childTaxonomyInfos = taxonomy.ChildTaxonomyDatas.Where(td => td.Active).Select(td => td.TaxonomyInfo).ToList();
count = childTaxonomyInfos.Count();
}
//else
// childTaxonomyInfos = GetLevel1Nodes().ToList();
//count += childTaxonomyInfos.Sum(childNode => GetNodeCount(childNode));
return(count);
}
private void ProcessTaxonomy(TaxonomyInfo taxonomy)
{
// set formatted taxonomy string
var taxonomyString = taxonomy.ToString(_args.IgnoreT1Taxonomy);
// get list of SKUs for this taxonomy
var allSkus = taxonomy.GetSkus(_args.ExportCrossListNodes);
if (!allSkus.Any())
{
return;
}
// filter skus based on sku inclusions and exclusions, then include only Product skus.
var skus = _args.GetFilteredSkuList(allSkus).ToList();
// process each sku...
skus.ForEach(sku =>
{
// write line to attribute file
if (taxonomy.NodeType == TaxonomyInfo.NodeTypeDerived)
{
var firstOrDefault = sku.SkuInfos.FirstOrDefault(a => a.Active);
if (firstOrDefault != null)
{
var originalTaxonomy = firstOrDefault.TaxonomyInfo;
var attributes = GetExportAttributes(originalTaxonomy);
ProcessAttributes(sku, "Cross List",
taxonomyString + TaxonomyInfo.CROSS_PREFIX +
originalTaxonomy.ToString(), attributes);
}
}
else
{
var attributes = GetExportAttributes(taxonomy);
ProcessAttributes(sku, TaxonomyInfo.NodeTypeRegular, taxonomyString, attributes);
}
});
}
// Public Methods (5)
public void GetAttributeOrders(
Attribute attribute, TaxonomyInfo taxonomy,
out decimal navAttOrder, out decimal dispAttOrder, out bool inSchema)
{
navAttOrder = 0;
dispAttOrder = 0;
inSchema = false;
if (taxonomy == null || attribute == null)
{
return;
}
inSchema = GetValue(taxonomy, attribute, SchemaAttributeInSchema) != null;
object nav = GetValue(taxonomy, attribute, SchemaAttributeNavigationOrder);
navAttOrder = nav != null ? (decimal)nav : 0;
object disp = GetValue(taxonomy, attribute, SchemaAttributeDisplayOrder);
dispAttOrder = disp != null ? (decimal)disp : 0;
}
private void ProcessTaxonomy(TaxonomyInfo taxonomy)
{
// set formatted taxonomy string
var taxonomyString = taxonomy.ToString(_args.IgnoreT1Taxonomy);
// get list of SKUs for this taxonomy
var allSkus = taxonomy.GetSkus(_args.ExportCrossListNodes);
if (!allSkus.Any())
{
return;
}
// filter skus based on sku inclusions and exclusions, then include only Product skus.
var skus = _args.GetFilteredSkuList(allSkus).ToList();
// process each sku...
skus.ForEach(sku =>
{
// get data on this sku's taxonomy history
var taxonomies = sku.SkuInfos.Select(
si =>
new
{
Taxonomy = si.TaxonomyInfo.OldString(),
SkuAssignedOn = si.CreatedOn,
SkuAssignedBy = si.User.FullName,
SkuAssignRemark = (si.CreatedRemark == null) ? String.Empty : si.Remark.Remark1,
TaxonomyCreatedOn = si.TaxonomyInfo.OldTaxonomyData == null
? string.Empty
: si.TaxonomyInfo.OldTaxonomyData.CreatedOn.ToString(CultureInfo.InvariantCulture),
TaxonomyCreatedBy = si.TaxonomyInfo.OldTaxonomyData == null
? string.Empty
: si.TaxonomyInfo.OldTaxonomyData.User.FullName
}).Where(d => !string.IsNullOrWhiteSpace(d.Taxonomy));
// write line to taxonomy file
if (taxonomy.NodeType == TaxonomyInfo.NodeTypeDerived)
{
var firstOrDefault = sku.SkuInfos.FirstOrDefault(a => a.Active);
if (firstOrDefault != null)
{
var originalTaxonomy = firstOrDefault.TaxonomyInfo;
WriteTaxonomyRow(sku.ItemID, taxonomyString + TaxonomyInfo.CROSS_PREFIX +
originalTaxonomy.ToString(), "Cross List", taxonomyString);
}
}
else
{
var firstOrDefault = taxonomies.FirstOrDefault();
if (firstOrDefault != null)
{
WriteTaxonomyRow(sku.ItemID, taxonomyString, TaxonomyInfo.NodeTypeRegular, firstOrDefault.Taxonomy);
}
}
// write line to attribute file
if (taxonomy.NodeType == TaxonomyInfo.NodeTypeDerived)
{
var firstOrDefault = sku.SkuInfos.FirstOrDefault(a => a.Active);
if (firstOrDefault != null)
{
var originalTaxonomy = firstOrDefault.TaxonomyInfo;
var attributes = GetExportAttributes(originalTaxonomy);
ProcessAttributes(sku, originalTaxonomy, "Cross List",
taxonomyString + TaxonomyInfo.CROSS_PREFIX +
originalTaxonomy.ToString(), attributes);
}
}
else
{
var attributes = GetExportAttributes(taxonomy);
ProcessAttributes(sku, taxonomy, TaxonomyInfo.NodeTypeRegular, taxonomyString, attributes);
}
});
}
private IEnumerable <Tuple <Attribute, decimal, decimal> > GetExportAttributes(TaxonomyInfo taxonomy)
{
if (_taxonomyAttributesCache.ContainsKey(taxonomy.ID))
{
return(_taxonomyAttributesCache[taxonomy.ID]);
}
var schemaInfos = new List <SchemaInfo>();
schemaInfos.AddRange(taxonomy.SchemaInfos.Where(si => si.SchemaDatas.Any(sd => sd.Active)).ToList());
if (_args.ExportSuperSchema)
{
foreach (var leaf in taxonomy.AllLeafChildren)
{
schemaInfos.AddRange(leaf.SchemaInfos.Where(si => si.SchemaDatas.Any(sd => sd.Active)).ToList());
}
}
var atts =
schemaInfos.Where(p => p.SchemaData.InSchema).Select(p => new { p.Attribute, p.SchemaData }).ToList();
List <Tuple <Attribute, decimal, decimal> > attributes;
if (_args.Top6OnlyAttributes)
{
var attrs = (from att in atts.Where(att => att.SchemaData != null && att.SchemaData.NavigationOrder > 0)
let baseAttributeName = GetBaseAttributeName(att.Attribute.AttributeName)
group att by baseAttributeName
into grp
let minNavRank = grp.Min(g => g.SchemaData.NavigationOrder)
orderby minNavRank
select new { BaseAttributeName = grp.Key, Attributes = grp.Select(p => p.Attribute) }).Take(6)
.SelectMany(p => p.Attributes)
.Distinct()
.ToList();
attributes = (from attribute1 in attrs
let schemaData = taxonomy.SchemaInfos.Single(si => si.AttributeID == attribute1.ID).SchemaData
select
schemaData == null
? new Tuple <Attribute, decimal, decimal>(attribute1, 0, 0)
: new Tuple <Attribute, decimal, decimal>(attribute1, schemaData.NavigationOrder,
schemaData.DisplayOrder)).ToList();
}
else
{
if (_args.ExportSuperSchema)
{
attributes = (from att in atts
group att by att.Attribute
into grp
let minRank = grp.Min(p => GetRank(p.SchemaData, SortOrder.OrderbyDisplayNavigation))
orderby minRank
select new Tuple <Attribute, decimal, decimal>(grp.Key, 0, minRank)).ToList();
}
else
{
attributes = (from att in atts
let rank = GetRank(att.SchemaData, _args.OrderAttributesBy)
orderby rank, att.Attribute.AttributeName
select
new Tuple <Attribute, decimal, decimal>(att.Attribute,
att.SchemaData == null ? 0 : att.SchemaData.NavigationOrder,
att.SchemaData == null ? 0 : att.SchemaData.DisplayOrder)).ToList();
}
}
//TODO: Check on whether Attribute Groups are needed.
// if (AttributeGroupExclusions.Length > 0)
// {
// //exclude Attribute Groups
// attributes =
// attributes.Where(
// p =>
// p.Item1.Group == null ||
// (!AttributeGroupExclusions.Contains(p.Item1.Group.ToLower()))).ToList();
// }
//
// if (AttributeGroupInclusions.Length > 0)
// {
// //include Attribute Groups
// attributes =
// attributes.Where(
// p =>
// p.Item1.Group == null ||
// (AttributeGroupInclusions.Contains(p.Item1.Group.ToLower()))).ToList();
// }
//
// if ((AttributeGroupExclusions.Length > 0 && AttributeGroupExclusions.Contains("default")) ||
// (AttributeGroupInclusions.Length > 0 && !AttributeGroupInclusions.Contains("default")))
// attributes = attributes.Where(p => p.Item1.Group != null).ToList();
_taxonomyAttributesCache.Add(taxonomy.ID, attributes);
return(attributes);
}
private void ProcessAttributes(Sku sku, TaxonomyInfo taxonomy, string nodeType, string taxonomyString,
IEnumerable <Tuple <Attribute, decimal, decimal> > attributeOrders)
{
// add static information to output lists
var valueElements = new List <string>();
valueElements.Add(sku.ItemID);
valueElements.Add(taxonomyString);
valueElements.Add(nodeType);
var blankElements = new List <string>();
if (_args.GenerateFileWithBlankValues)
{
blankElements.Add(sku.ItemID);
blankElements.Add(taxonomyString);
blankElements.Add(nodeType);
}
// add global attributes
for (int i = 0; i < _globalAttributeNames.Count(); i++)
{
// get list of sub-attributes in this attribute, then collect their values
var parts = _globalAttributeNames[i].Split(new[] { ',' });
var values = new List <EntityData>();
foreach (var att in parts)
{
values.AddRange(sku.GetValuesForAttribute(CurrentDb, att.Trim()));
}
if (_globalAttributeCount[i] == 0)
{
// if there's no specified number of columns for this attribute, string the values together
var stringValue =
values.Select(val =>
(val.Value + (_args.IncludeUoM ? " " + val.Uom : ""))
.Trim())
.Distinct()
.OrderBy(val => val, new CompareForAlphaNumericSort())
.Aggregate(string.Empty, (current, val) => current + ((string.IsNullOrEmpty(current) ? string.Empty : ",") + val));
valueElements.Add(stringValue);
if (_args.GenerateFileWithBlankValues)
{
blankElements.Add(stringValue);
}
}
else
{
// if there are multiple columns for this attribute, assign the values separately, limited by the count of collumns
var listStringValue =
values.Select(val =>
(val.Value + (_args.IncludeUoM ? " " + val.Uom : ""))
.Trim())
.Distinct()
.OrderBy(val => val, new CompareForAlphaNumericSort())
.Take(_globalAttributeCount[i])
.ToList();
for (int j = 0; j < _globalAttributeCount[i]; j++)
{
if (j < listStringValue.Count)
{
valueElements.Add(listStringValue[j]);
if (_args.GenerateFileWithBlankValues)
{
blankElements.Add(listStringValue[j]);
}
}
else
{
valueElements.Add("");
if (_args.GenerateFileWithBlankValues)
{
blankElements.Add("");
}
}
}
}
}
// collect data for each attribute
bool writeBlankRow = false;
foreach (var att in attributeOrders)
{
//Attribute,NavOrder,DisplayOrder
var attributeOrder = att;
var navOrder = att.Item2;
var dispOrder = att.Item3;
if (((_args.ExportNavigationAttributes && navOrder > 0) || (_args.ExportDisplayAttributes && dispOrder > 0) ||
(_args.ExportUnRankedAttributes && navOrder == 0 && dispOrder == 0)))
{
var entity = sku.GetValuesForAttribute(CurrentDb, attributeOrder.Item1.AttributeName);
// concatenate the values into a comma-delimited string
var value = entity.Aggregate(string.Empty,
(current, ed) =>
current + (string.IsNullOrEmpty(current) ? string.Empty : ", ") + ed.Value);
//display the uom once if there is one distinct uom, otherwise, output in the same order as the value (optional)
string uom = String.Empty;
if (_args.IncludeUoM)
{
var distinctUoms =
entity.Where(ed => !string.IsNullOrWhiteSpace(ed.Uom))
.Select(ed => ed.Uom)
.Distinct()
.ToList();
uom = distinctUoms.Aggregate(String.Empty, (current, next) => current + (string.IsNullOrEmpty(current) ? string.Empty : ", ") + next);
}
// concatenate field 1 into a comma-delimited string
string field1 = String.Empty;
if (_args.IncludeField1)
{
var distinctField1 =
entity.Where(ed => !string.IsNullOrWhiteSpace(ed.Field1))
.Select(ed => ed.Field1)
.Distinct()
.ToList();
field1 = distinctField1.Aggregate(String.Empty, (current, next) => current + (string.IsNullOrEmpty(current) ? string.Empty : ", ") + next);
}
// concatenate field 2 into a comma-delimited string
string field2 = String.Empty;
if (_args.IncludeField2)
{
var distinctField2 =
entity.Where(ed => !string.IsNullOrWhiteSpace(ed.Field2))
.Select(ed => ed.Field2)
.Distinct()
.ToList();
field2 = distinctField2.Aggregate(String.Empty, (current, next) => current + (string.IsNullOrEmpty(current) ? string.Empty : ", ") + next);
}
// concatenate field 3 into a comma-delimited string
string field3 = String.Empty;
if (_args.IncludeField3)
{
var distinctField3 =
entity.Where(ed => !string.IsNullOrWhiteSpace(ed.Field3))
.Select(ed => ed.Field3)
.Distinct()
.ToList();
field3 = distinctField3.Aggregate(String.Empty, (current, next) => current + (string.IsNullOrEmpty(current) ? string.Empty : ", ") + next);
}
// concatenate field 4 into a comma-delimited string
string field4 = String.Empty;
if (_args.IncludeField4)
{
var distinctField4 =
entity.Where(ed => !string.IsNullOrWhiteSpace(ed.Field4))
.Select(ed => ed.Field4)
.Distinct()
.ToList();
field4 = distinctField4.Aggregate(String.Empty, (current, next) => current + (string.IsNullOrEmpty(current) ? string.Empty : ", ") + next);
}
// concatenate field 5 into a comma-delimited string
string field5 = String.Empty;
if (_args.IncludeField5)
{
var distinctField5 =
entity.Where(ed => !string.IsNullOrWhiteSpace(ed.Field5OrStatus))
.Select(ed => ed.Field5OrStatus)
.Distinct()
.ToList();
field5 = distinctField5.Aggregate(String.Empty, (current, next) => current + (string.IsNullOrEmpty(current) ? string.Empty : ", ") + next);
}
// optionally, get the navigation data
var rank = string.Empty;
if (navOrder > 0 || dispOrder > 0)
{
if (_args.ExportNavigationAttributes)
{
rank = _args.ExportSuperSchema && taxonomy.IsLeafNode
? "S"
: Decimal.Truncate(navOrder).ToString(CultureInfo.InvariantCulture);
}
if (_args.ExportDisplayAttributes)
{
if (_args.ExportNavigationAttributes)
{
rank += " • ";
}
rank += Decimal.Truncate(dispOrder).ToString(CultureInfo.InvariantCulture);
}
}
// add attribute data to output list
// append navigation data
if (_args.ExportRanks)
{
valueElements.Add(rank);
}
// append attribute name
valueElements.Add(attributeOrder.Item1.AttributeName);
if (_args.ExportNewValueColumn)
{
valueElements.Add("");
}
// append value data
valueElements.Add(value);
// append UoM data
if (_args.IncludeUoM)
{
valueElements.Add(uom);
}
// append field 1 data
if (_args.IncludeField1)
{
valueElements.Add(field1);
}
// append field 2 data
if (_args.IncludeField2)
{
valueElements.Add(field2);
}
// append field 3 data
if (_args.IncludeField3)
{
valueElements.Add(field3);
}
// append field 4 data
if (_args.IncludeField4)
{
valueElements.Add(field4);
}
// append field 5 data
if (_args.IncludeField5)
{
valueElements.Add(field5);
}
if (_args.GenerateFileWithBlankValues && string.IsNullOrWhiteSpace(value))
{
// signal that there are blank values to be written
writeBlankRow = true;
// append navigation data
if (_args.ExportRanks)
{
blankElements.Add(rank);
}
// append attribute name
blankElements.Add(attributeOrder.Item1.AttributeName);
if (_args.ExportNewValueColumn)
{
blankElements.Add("");
}
// append value data - should be blank
blankElements.Add("");
// append UoM data
if (_args.IncludeUoM)
{
blankElements.Add(uom);
}
// append field 1 data
if (_args.IncludeField1)
{
blankElements.Add(field1);
}
// append field 2 data
if (_args.IncludeField2)
{
blankElements.Add(field2);
}
// append field 3 data
if (_args.IncludeField3)
{
blankElements.Add(field3);
}
// append field 4 data
if (_args.IncludeField4)
{
blankElements.Add(field4);
}
// append field 5 data
if (_args.IncludeField5)
{
blankElements.Add(field5);
}
}
}
}
_attributeTable.WriteDataRow(valueElements);
if (_args.GenerateFileWithBlankValues && writeBlankRow)
{
_blankAttributeTable.WriteDataRow(blankElements);
}
}
private bool CreateTaxonomy(TaxonomyInterchangeRecord currentTaxonomyPath)
{
var isTaxonomyNew = false;
//double check to make sure that this taxonomy doesn't already exist - should never be executed...
if (currentTaxonomyPath == null ||
_existingTaxonomyPathsAndIDs.ContainsKey(currentTaxonomyPath.TaxonomyPath.ToLower()))
{
return(false);
}
// split taxonomy into nodes
var taxonomyParts = currentTaxonomyPath.TaxonomyPath.Split(new[] { '>' });
var taxonomyPathPrefix = new StringBuilder();
Guid?parentTaxonomyId = null;
foreach (var taxNode in taxonomyParts)
{
// if this is the first node, don't add a delimiter
if (taxonomyPathPrefix.Length > 0)
{
taxonomyPathPrefix.Append(">");
}
taxonomyPathPrefix.Append(taxNode);
var tempTaxonomyPathPrefix = taxonomyPathPrefix.ToString();
// check to see if the taxonomy's parent is present - if so, get its id.
// we keep iterating down the branch until we find a space for the taxonomy.
// keep going until the entire taxonomy string is accounted for.
if (_existingTaxonomyPathsAndIDs.ContainsKey(tempTaxonomyPathPrefix.ToLower()))
{
parentTaxonomyId = _existingTaxonomyPathsAndIDs[tempTaxonomyPathPrefix.ToLower()];
}
else
{
var newTaxonomyInfo = new TaxonomyInfo(CurrentDbContext)
{
ProjectID = CurrentProjectId, ShowInTree = false, NodeType = TaxonomyInfo.NodeTypeRegular
};
newTaxonomyInfo.TaxonomyDatas.Add(new TaxonomyData(CurrentDbContext)
{
TaxonomyID = newTaxonomyInfo.ID,
ParentTaxonomyID = parentTaxonomyId,
NodeName = taxNode,
CreatedBy = ImportRequestedBy,
CreatedOn = DateTime.Now,
CreatedRemark = CurrentRemarkId
});
CurrentDbContext.TaxonomyInfos.InsertOnSubmit(newTaxonomyInfo);
//add it to the cache for future reuse
_existingTaxonomyPathsAndIDs.Add(tempTaxonomyPathPrefix.ToLower(), newTaxonomyInfo.ID);
parentTaxonomyId = newTaxonomyInfo.ID;
isTaxonomyNew = true;
}
}
return(isTaxonomyNew);
}
private IEnumerable <KeyValuePair <Attribute, SchemaData> > GetExportAttributes(TaxonomyInfo taxonomy)
{
if (_taxonomyAttributesCache.ContainsKey(taxonomy.ID))
{
return(_taxonomyAttributesCache[taxonomy.ID]);
}
var schemaInfos = new List <SchemaInfo>();
schemaInfos.AddRange(taxonomy.SchemaInfos.Where(si => si.SchemaDatas.Any(sd => sd.Active)).ToList());
var attributes = (from si in schemaInfos
let rank = GetRank(si.SchemaData, SortOrder.OrderbyNavigationDisplay)
where si.SchemaData.InSchema
orderby rank, si.Attribute.AttributeName
select new KeyValuePair <Attribute, SchemaData>(si.Attribute, si.SchemaData)).ToList();
_taxonomyAttributesCache.Add(taxonomy.ID, attributes);
return(attributes);
}
public static string GetMetaAttributeValue(Attribute attribute, Attribute metaAttribute, TaxonomyInfo taxonomy)
{
try
{
var si = taxonomy.SchemaInfos.FirstOrDefault(a => a.Attribute == attribute);
//var si = Arya.SchemaInfos.Where(t => t.TaxonomyID == Guid.Empty && t.Attribute == attribute ).FirstOrDefault();
//if (si == null)
// return null;
var smi = si.SchemaMetaInfos.FirstOrDefault(mi => mi.MetaAttributeID == metaAttribute.ID);
//if (smi == null)
// return null;
var smd = smi.SchemaMetaDatas.FirstOrDefault(a => a.Active);
//if (smd == null)
// return null;
//else
return(smd.Value);
}
catch (NullReferenceException)
{
return(null);
}
}
public string SetValue(
TaxonomyInfo taxonomy, Attribute attribute, bool autoMapSchema, SchemaAttribute schematus, object value, bool suppressAutoMapMessage = false)
{
SchemaInfo schemaInfo = taxonomy.SchemaInfos.FirstOrDefault(si => si.Attribute.Equals(attribute));
bool newSchemaInfo = false;
if (schemaInfo == null)
{
if (suppressAutoMapMessage)
{
return(null);
}
if (!autoMapSchema &&
MessageBox.Show(
String.Format(
"Attribute [{0}] is not mapped in Node [{1}]. Do you want to map it?", attribute,
taxonomy.TaxonomyData.NodeName), @"Add to Schema", MessageBoxButtons.YesNo) ==
DialogResult.No)
{
return(null);
}
schemaInfo = new SchemaInfo {
Attribute = attribute
};
taxonomy.SchemaInfos.Add(schemaInfo);
newSchemaInfo = true;
}
if (schematus == null)
{
//Create/Update Schema Info only
SchemaData currentSchemaData = schemaInfo.SchemaData;
var newSchemaData = new SchemaData();
if (value != null && value is SchemaData)
{
var fromSchemaData = (SchemaData)value;
if (currentSchemaData != null && currentSchemaData.Equals(fromSchemaData))
{
return(null);
}
newSchemaData.DataType = fromSchemaData.DataType;
newSchemaData.DisplayOrder = fromSchemaData.DisplayOrder;
newSchemaData.NavigationOrder = fromSchemaData.NavigationOrder;
newSchemaData.InSchema = fromSchemaData.InSchema;
}
if (currentSchemaData != null)
{
currentSchemaData.Active = false;
}
schemaInfo.SchemaDatas.Add(newSchemaData);
return(null);
}
SchemaData activeSd = schemaInfo.SchemaData;
switch (schematus.AttributeType)
{
case SchemaAttributeType.Primary:
bool reallyNewSd = false;
bool reorderRanks = false;
SchemaData newSchemaData;
if (activeSd == null)
{
reallyNewSd = true;
newSchemaData = new SchemaData();
}
else
{
//activeSd.DeletedBy = AryaTools.Instance.InstanceData.CurrentUser.ID;
activeSd.DeletedByUser = CurrentUser; //fixes Object not found error
activeSd.DeletedOn = DateTime.Now;
newSchemaData = new SchemaData
{
DataType = activeSd.DataType, InSchema = activeSd.InSchema,
NavigationOrder = activeSd.NavigationOrder,
DisplayOrder = activeSd.DisplayOrder
};
}
string propertyName = schematus.PrimarySchemaAttribute.Replace(" ", String.Empty);
PropertyInfo valueProperty = newSchemaData.GetType().GetProperty(propertyName);
Type propertyType = valueProperty.PropertyType;
if (propertyType == typeof(string))
{
object stringValue = value ?? String.Empty;
if (propertyName == "DataType")
{
stringValue = ValidateDataType(stringValue);
}
if (!(valueProperty.GetValue(newSchemaData, null) ?? String.Empty).Equals(stringValue))
{
reallyNewSd = true;
valueProperty.SetValue(newSchemaData, stringValue.ToString(), null);
}
}
else if (propertyType == typeof(bool))
{
object boolValue = value ?? false;
string firstCharacter;
try
{
firstCharacter = boolValue.ToString().Substring(0, 1).ToLower();
}
catch (Exception)
{
firstCharacter = "f";
}
bool newValue = firstCharacter.Equals("t") || firstCharacter.Equals("y") ||
firstCharacter.Equals("1");
if (!((bool)valueProperty.GetValue(newSchemaData, null)).Equals(newValue))
{
reallyNewSd = true;
valueProperty.SetValue(newSchemaData, newValue, null);
}
}
//else if (propertyType == typeof (decimal))
//{
// object decimalValue = value ?? 0.0;
// decimal newDecimalValue;
// if (Decimal.TryParse(decimalValue.ToString(), out newDecimalValue))
// {
// if (!((decimal) valueProperty.GetValue(newSchemaData, null)).Equals(newDecimalValue))
// {
// reallyNewSd = true;
// valueProperty.SetValue(newSchemaData, newDecimalValue, null);
// reorderRanks = SchemaDataGridView.AutoOrderRanks;
// }
// }
// else
// return String.Format(
// "Invalid value [{0}] for [{1}] - [{2}].{3}Expected a decimal value.", decimalValue,
// taxonomy.NodeName, attribute, Environment.NewLine);
//}
else
{
return(String.Format(
"Unknown data type for value [{0}] for [{1}] - [{2}]", value ?? String.Empty,
taxonomy.NodeName, attribute));
}
if (reallyNewSd)
{
if (activeSd != null)
{
activeSd.Active = false;
}
schemaInfo.SchemaDatas.Add(newSchemaData);
if (reorderRanks)
{
AutoOrderRanks(newSchemaData.SchemaInfo.TaxonomyInfo, newSchemaData);
}
}
return(null);
case SchemaAttributeType.Meta:
bool reallyNewSmd = false;
if (schematus.DataType == typeof(bool))
{
value = value.ToString().StartsWith("y", StringComparison.OrdinalIgnoreCase) ? "Yes" : "No";
}
//First check if there is an active SchemaData
if (activeSd == null)
{
if (suppressAutoMapMessage)
{
return(null);
}
if (!newSchemaInfo && !autoMapSchema &&
MessageBox.Show(
String.Format(
"Attribute [{0}] is not mapped in Node [{1}]. Do you want to map it?", attribute,
taxonomy.TaxonomyData.NodeName), "Add to Schema", MessageBoxButtons.YesNo) ==
DialogResult.No)
{
return(null);
}
schemaInfo.SchemaDatas.Add(new SchemaData());
reallyNewSmd = true;
}
SchemaMetaInfo activeSmi = (from mi in schemaInfo.SchemaMetaInfos
where mi.Attribute.Equals(schematus.MetaSchemaAttribute)
select mi).FirstOrDefault();
if (activeSmi == null)
{
activeSmi = new SchemaMetaInfo {
Attribute = schematus.MetaSchemaAttribute
};
schemaInfo.SchemaMetaInfos.Add(activeSmi);
reallyNewSmd = true;
}
SchemaMetaData activeSmd = activeSmi.SchemaMetaData;
if (activeSmd == null)
{
reallyNewSmd = true;
}
else if (value == null || !activeSmd.Value.Equals(value))
{
reallyNewSmd = true;
activeSmd.Active = false;
}
//if (reallyNewSmd && value != null && !String.IsNullOrEmpty(value.ToString()))
//{
// activeSmi.SchemaMetaDatas.Add(new SchemaMetaData {Value = value.ToString()});
// SchemaDataGridView.UpdateAutoCompleteSource(schematus.MetaSchemaAttribute, value.ToString());
//}
return(null);
default:
return("Unknown Meta-attribute Type! Weird!!!");
}
}
public object GetValue(TaxonomyInfo taxonomy, Attribute attribute, SchemaAttribute schematus)
{
if (taxonomy == null && attribute == null)
{
return(schematus);
}
if (taxonomy == null)
{
return(attribute);
}
if (attribute == null)
{
return(taxonomy);
}
var schemaInfo = taxonomy.SchemaInfos.FirstOrDefault(si => si.Attribute != null && si.Attribute.Equals(attribute));
if (schematus == null || schemaInfo == null)
{
return(null);
}
switch (schematus.AttributeType)
{
case SchemaAttributeType.Primary:
SchemaData activeSchemaData = schemaInfo.SchemaDatas.FirstOrDefault(sd => sd.Active);
if (activeSchemaData == null)
{
return(null);
}
PropertyInfo valueProperty =
activeSchemaData.GetType().GetProperty(schematus.PrimarySchemaAttribute.Replace(" ", String.Empty));
return(valueProperty.GetValue(activeSchemaData, null));
case SchemaAttributeType.Meta:
SchemaMetaData metaSchemaData = (from mi in schemaInfo.SchemaMetaInfos
where mi.Attribute.Equals(schematus.MetaSchemaAttribute) && mi.SchemaMetaData != null
select mi.SchemaMetaData).FirstOrDefault();
return(metaSchemaData);
case SchemaAttributeType.Special:
if (schematus.SpecialSchemaAttribute.Equals(SpecialSchematusIsMapped))
{
SchemaData activeSd = schemaInfo.SchemaDatas.FirstOrDefault(sd => sd.Active);
if (activeSd != null)
{
return("x");
}
}
if (schematus.SpecialSchemaAttribute.Equals(SpecialSchematusAttributeType))
{
return(attribute.AttributeType);
}
if (schematus.SpecialSchemaAttribute.Equals(SpecialSchematusListOfValues))
{
var listOfValues = schemaInfo.ListOfValues.Where(lov => lov.Active == true).Select(lov => lov).ToList();
if (listOfValues.Any())
{
string listSep = Currentproject.ProjPreferences.ListSeparator ?? "; ";
return(listOfValues.OrderBy(val => val.DisplayOrder).ThenBy(val => val.Value).Select(val => val.Value).Aggregate((current, lov) => current + listSep + lov));
}
else
{
return(null);
}
}
return(null);
//case SchemaAttributeType.FillRate:
// double? fillRate = AryaTools.Instance.AllFillRates.GetFillRate(
// taxonomy, attribute, schematus.FillRateSchemaAttribute);
// if (fillRate == Double.MinValue)
// {
// SchemaDataGridView.RefreshGridView = true;
// return "Calculating...";
// }
// return fillRate;
default:
return(null);
}
}
public void AutoOrderRanks(TaxonomyInfo taxonomy, SchemaData schemaData)
{
if (taxonomy == null)
{
return;
}
Dictionary <SchemaData, decimal[]> sds = (from si in taxonomy.SchemaInfos
let sd = si.SchemaData
where sd != null && (sd.NavigationOrder > 0 || sd.DisplayOrder > 0)
select sd).ToDictionary(
sd => sd, sd => new[] { sd.NavigationOrder, sd.DisplayOrder });
if (!sds.Any())
{
return;
}
decimal baseNavOrder = schemaData != null ? schemaData.NavigationOrder : 0;
decimal baseDispOrder = schemaData != null ? schemaData.DisplayOrder : 0;
List <SchemaData> navs = (from sd in sds
where
sd.Key.NavigationOrder > 0 && sd.Key.NavigationOrder >= baseNavOrder &&
(schemaData == null || !sd.Key.Equals(schemaData))
select sd.Key).ToList();
foreach (SchemaData nav in navs)
{
sds[nav][0] = nav.NavigationOrder + 1;
}
int iCtr = 0;
foreach (SchemaData nav in
(from sd in sds
where sd.Value[0] > 0
orderby sd.Value[0]
select sd.Key).ToList())
{
sds[nav][0] = ++iCtr;
}
List <SchemaData> disps = (from sd in sds
where
sd.Key.DisplayOrder > 0 && sd.Key.DisplayOrder >= baseDispOrder &&
(schemaData == null || !sd.Key.Equals(schemaData))
select sd.Key).ToList();
foreach (SchemaData disp in disps)
{
sds[disp][1] = disp.DisplayOrder + 1;
}
iCtr = 0;
foreach (SchemaData disp in
(from sd in sds
where sd.Value[1] > 0
orderby sd.Value[1]
select sd.Key).ToList())
{
sds[disp][1] = ++iCtr;
}
foreach (var kvp in sds)
{
SchemaInfo schemaInfo = kvp.Key.SchemaInfo;
SetValue(
schemaInfo.TaxonomyInfo, schemaInfo.Attribute, false, SchemaAttributeNavigationOrder, kvp.Value[0]);
SetValue(
schemaInfo.TaxonomyInfo, schemaInfo.Attribute, false, SchemaAttributeDisplayOrder, kvp.Value[1]);
}
}