public void UpdateNodeCounts(Arya.Data.TaxonomyInfo taxonomy)
{
if (_treeForm != null && !_treeForm.IsDisposed)
{
_treeForm.taxonomyTree.UpdateNodeCounts(taxonomy, true);
}
}
private IEnumerable <string> GetLovs(Attribute attribute, TaxonomyInfo taxonomy)
{
return(AryaTools.Instance.InstanceData.Dc.ExecuteQuery <string>(
@"SELECT distinct ed.Value
FROM EntityData ed
INNER JOIN EntityInfo ei ON ed.Active = 1 AND ed.EntityID = ei.ID AND ed.AttributeID = {0}
INNER JOIN SkuInfo si ON si.Active = 1 AND ei.SkuID = si.SkuID AND si.TaxonomyID = {1}",
attribute.ID, taxonomy.ID).OrderBy(p => p, new CompareForAlphaNumericSort()).ToList());
}
/// <summary>
/// Match Taxonomy for the specified Link
/// </summary>
private static bool ValidateMatchedLinks(FilteredSkuLink link, out string leftTaxonomy, out string rightTaxonomy)
{
//Batch>One-One|Rep.>Images|Skus
const int numberOfTopTaxonomyLevelsToSkip = 3;
leftTaxonomy = TaxonomyInfo.StripTopLevelNodes(link.LeftTaxonomy.ToString(), numberOfTopTaxonomyLevelsToSkip);
rightTaxonomy = TaxonomyInfo.StripTopLevelNodes(link.RightTaxonomy.ToString(), numberOfTopTaxonomyLevelsToSkip);
return(leftTaxonomy.Equals(rightTaxonomy));
}
public static CrossListCriteria GetCrossListObject(TaxonomyInfo taxInfo)
{
if (AryaTools.Instance.InstanceData.Dc.DerivedTaxonomies.Any(t => t.TaxonomyID == taxInfo.ID))
{
var cl = AryaTools.Instance.InstanceData.Dc.DerivedTaxonomies.Where(t => t.TaxonomyID == taxInfo.ID).Select(ex => ex.Expression).Single().DeSerializeXElement();
//cl.TaxonomyIDFilter = cl.TaxonomyIDFilter.GetTaxonomyIDs(cl.IncludeChildren); //Get SKUs in all the child Nodes to Display in SKU View - Cross Ref
return(cl);
}
return(null);
}
public static void OrderByDisplay(TaxonomyInfo taxonomy)
{
if (taxonomy == null)
{
return;
}
var 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 (var 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)
{
var 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 EntityData ProcessCalculatedAttribute(Attribute att, TaxonomyInfo tax,
bool getDefaultForNullTaxonomy = true)
{
if (tax == null)
{
var globalDerivedAttribute = att.DerivedAttributes.FirstOrDefault(p => p.TaxonomyID == Guid.Empty);
if (globalDerivedAttribute != null)
{
return(ProcessCalculatedAttribute(globalDerivedAttribute.Expression,
globalDerivedAttribute.MaxResultLength));
}
tax = _sku.Taxonomy;
if (tax == null || !getDefaultForNullTaxonomy)
{
return new EntityData(false)
{
Value = String.Empty
}
}
;
}
var calculatedAttribute =
att.DerivedAttributes.FirstOrDefault(da => da.TaxonomyInfo != null && da.TaxonomyID == tax.ID);
if (calculatedAttribute == null && att.DerivedAttributes.Any(da => da.TaxonomyInfo == null))
{
calculatedAttribute = att.DerivedAttributes.First(da => da.TaxonomyInfo == null);
}
//I wonder why we are setting the calculatedAttribute to NULL if an Active InSchema SchemaData exists
//if (calculatedAttribute != null)
//{
// if (sourceTaxonomy != null)
// {
// var schemaInfo = sourceTaxonomy.SchemaInfos.SingleOrDefault(p => p.AttributeID == att.ID);
// if (schemaInfo != null && !schemaInfo.SchemaDatas.Any(sd => sd.Active && sd.InSchema))
// calculatedAttribute = null;
// }
//}
if (calculatedAttribute == null)
{
return(ProcessCalculatedAttribute(att, tax.TaxonomyData.ParentTaxonomyInfo, false));
}
return(ProcessCalculatedAttribute(calculatedAttribute.Expression, calculatedAttribute.MaxResultLength));
}
private List <Attribute> GetInSchemaAttributes(TaxonomyInfo taxonomy)
{
if (_inSchemaAttributes.ContainsKey(taxonomy))
{
return(_inSchemaAttributes[taxonomy]);
}
var atts = (from si in taxonomy.SchemaInfos
where si.SchemaDatas.Any(sd => sd.Active && sd.InSchema)
select si.Attribute).ToList();
_inSchemaAttributes.Add(taxonomy, atts);
return(atts);
}
private void PopulateLov(bool overwrite)
{
// determine location
Attribute attribute = SchemaInfo.Attribute;
TaxonomyInfo taxonomy = SchemaInfo.TaxonomyInfo;
Guid waitkey =
FrmWaitScreen.ShowMessage(string.Format("Populating LOVs - {0} - {1}", taxonomy.NodeName,
attribute.AttributeName));
// get values from database
var listOfValues = GetLovs(attribute, taxonomy);
SchemaInfo schemaInfo = taxonomy.SchemaInfos.FirstOrDefault(si => si.Attribute.Equals(attribute));
if (schemaInfo != null)
{
if (overwrite)
{
// assign database values to list of values
schemaInfo.ActiveListOfValues = listOfValues;
}
else
{
// compare current list of values to database and add
// missing database values to list of values
var currentLov = schemaInfo.ActiveListOfValues.ToList();
foreach (var lov in listOfValues)
{
if (!currentLov.Contains(lov))
{
currentLov.Add(lov);
}
}
schemaInfo.ActiveListOfValues = currentLov;
}
}
// save new list of values
AryaTools.Instance.SaveChangesIfNecessary(false, false);
FrmWaitScreen.HideMessage(waitkey);
// refresh list of values form
AryaTools.Instance.Forms.ListofValuesForm.SchemaInfo = schemaInfo;
}
public static void UnmapNodeAttribute(TaxonomyInfo taxonomy, Attribute attribute)
{
var 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 Methods (5)
public static 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;
var nav = GetValue(taxonomy, attribute, SchemaAttributeNavigationOrder);
navAttOrder = nav != null ? (decimal)nav : 0;
var disp = GetValue(taxonomy, attribute, SchemaAttributeDisplayOrder);
dispAttOrder = disp != null ? (decimal)disp : 0;
}
private static string GetImageName(TaxonomyInfo taxonomy, Guid skuId)
{
var ImagefileName = string.Empty;
var imageSku = taxonomy.SkuInfos.Select(si => si.Sku).FirstOrDefault(si => si.ID == skuId);
// var imageSku = AryaTools.Instance.InstanceData.Dc.Skus.FirstOrDefault(sk => sk.ID == skuId);
if (imageSku == null)
{
return(string.Empty);
}
using (
var dc = new AryaDbDataContext(AryaTools.Instance.InstanceData.CurrentProject.ID,
AryaTools.Instance.InstanceData.CurrentUser.ID))
{
var imageMgr = new ImageManager(dc, AryaTools.Instance.InstanceData.CurrentProject.ID)
{
ImageSku = dc.Skus.FirstOrDefault(sku => sku.ID == imageSku.ID)
};
ImagefileName = Path.GetFileName(imageMgr.OriginalFileUri);
return(ImagefileName);
}
}
public static string SetValue(TaxonomyInfo taxonomy, Attribute attribute, bool autoMapSchema,
SchemaAttribute schematus, object value, bool suppressAutoMapMessage = false)
{
var schemaInfo = taxonomy.SchemaInfos.FirstOrDefault(si => si.Attribute.Equals(attribute));
var 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
var 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);
}
var activeSd = schemaInfo.SchemaData;
switch (schematus.AttributeType)
{
case SchemaAttributeType.Primary:
var reallyNewSd = false;
var reorderRanks = false;
SchemaData newSchemaData;
if (activeSd == null)
{
reallyNewSd = true;
newSchemaData = new SchemaData();
}
else
{
//activeSd.DeletedBy = AryaTools.Instance.InstanceData.CurrentUser.ID;
activeSd.DeletedByUser = AryaTools.Instance.InstanceData.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
};
}
var propertyName = schematus.PrimarySchemaAttribute.Replace(" ", String.Empty);
var valueProperty = newSchemaData.GetType().GetProperty(propertyName);
var propertyType = valueProperty.PropertyType;
if (propertyType == typeof(string))
{
var 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))
{
var boolValue = value ?? false;
string firstCharacter;
try
{
firstCharacter = boolValue.ToString().Substring(0, 1).ToLower();
}
catch (Exception)
{
firstCharacter = "f";
}
var 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))
{
var 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:
var 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;
}
var 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;
}
var 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 static 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:
var activeSchemaData = schemaInfo.SchemaDatas.FirstOrDefault(sd => sd.Active);
if (activeSchemaData == null)
{
return(null);
}
var valueProperty =
activeSchemaData.GetType()
.GetProperty(schematus.PrimarySchemaAttribute.Replace(" ", String.Empty));
return(valueProperty.GetValue(activeSchemaData, null));
case SchemaAttributeType.Meta:
var metaSchemaData = (from mi in schemaInfo.SchemaMetaInfos
where mi.Attribute.Equals(schematus.MetaSchemaAttribute) && mi.SchemaMetaData != null
select mi.SchemaMetaData).FirstOrDefault();
if (schematus.MetaSchemaAttribute.AttributeName == Framework.Properties.Resources.SchemaEnrichmentImageAttributeName)
{
if (metaSchemaData == null || string.IsNullOrEmpty(metaSchemaData.Value))
{
return(metaSchemaData);
}
Guid guidValue;
var isGuid = Guid.TryParse(metaSchemaData.Value, out guidValue);
return(isGuid ? GetImageName(taxonomy, new Guid(metaSchemaData.Value)) : metaSchemaData.Value);
//AryaTools.Instance.InstanceData.Dc.Skus.First(sk => sk.ID.ToString() == metaSchemaData.ToString()).EntityInfos.Where(ei => ei.EntityDatas.Where(ed => ed.Attribute.AttributeName == "Image FileName"));
//Sku imageSku = taxonomy.SkuInfos.FirstOrDefault(si => si.Sku.SkuType == Framework.Data.AryaDb.Sku.ItemType.EnrichmentImage.ToString()).Sku;
}
return(metaSchemaData);
case SchemaAttributeType.Special:
if (schematus.SpecialSchemaAttribute.Equals(SpecialSchematusIsMapped))
{
var activeSd = schemaInfo.SchemaDatas.FirstOrDefault(sd => sd.Active);
if (activeSd != null)
{
return("x");
}
}
if (schematus.SpecialSchemaAttribute.Equals(SpecialSchematusAttributeType))
{
if (attribute.AttributeType == "Sku")
{
return("Product");
}
return(attribute.Type);
}
if (schematus.SpecialSchemaAttribute.Equals(SpecialSchematusListOfValues))
{
var listOfValues = schemaInfo.ListOfValues.Where(lov => lov.Active).Select(lov => lov).ToList();
if (listOfValues.Any())
{
var listSep =
AryaTools.Instance.InstanceData.CurrentProject.ProjectPreferences.ListSeparator
?? "; ";
return
(listOfValues.OrderBy(val => val.DisplayOrder)
.ThenBy(val => val.Value)
.Select(val => val.Value)
.Aggregate((current, lov) => current + listSep + lov));
}
return(null);
}
return(null);
case SchemaAttributeType.FillRate:
var fillRate = AryaTools.Instance.AllFillRates.GetFillRate(taxonomy, attribute,
schematus.FillRateSchemaAttribute);
if (fillRate == Double.MinValue)
{
SchemaDataGridView.RefreshGridView = true;
return("Calculating...");
}
return(fillRate);
default:
return(null);
}
}
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 static void AutoOrderRanks(TaxonomyInfo taxonomy, SchemaData schemaData)
{
if (taxonomy == null)
{
return;
}
var 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;
}
var baseNavOrder = schemaData != null ? schemaData.NavigationOrder : 0;
var baseDispOrder = schemaData != null ? schemaData.DisplayOrder : 0;
var 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 (var nav in navs)
{
sds[nav][0] = nav.NavigationOrder + 1;
}
var iCtr = 0;
foreach (var nav in
(from sd in sds where sd.Value[0] > 0 orderby sd.Value[0] select sd.Key).ToList())
{
sds[nav][0] = ++iCtr;
}
var 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 (var disp in disps)
{
sds[disp][1] = disp.DisplayOrder + 1;
}
iCtr = 0;
foreach (var 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)
{
var 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 TaxAttValueCalculator(Sku sku)
{
_sku = sku;
sourceTaxonomy = _sku.Taxonomy;
}
