/// <summary> /// /// This method will iterate through a list of Products and apply the default value to every instance /// of an empty Attribute (i.e., in every DataRow of its Group). /// /// <param name="poProducts">The product list that we are iterating through</param> /// <param name="poDefaultValues">The default values for Attributes</param> /// <returns>None</returns> /// </summary> public static void ApplyDefaults(List <WonkaProduct> poProducts, Dictionary <int, string> poDefaultValues) { foreach (WonkaProduct TempProduct in poProducts) { var iDefaultValEnumerator = poDefaultValues.GetEnumerator(); while (iDefaultValEnumerator.MoveNext()) { int nDefaultAttrId = iDefaultValEnumerator.Current.Key; string sDefaultAttrValue = iDefaultValEnumerator.Current.Value; WonkaRefAttr TempAttr = WonkaRefEnvironment.GetInstance().GetAttributeByAttrId(nDefaultAttrId); WonkaPrdGroup TargetGroup = TempProduct.GetProductGroup(TempAttr.GroupId); foreach (WonkaPrdGroupDataRow TempDataRow in TargetGroup) { string sTempValue = TempDataRow[TempAttr.AttrId]; if (String.IsNullOrEmpty(sTempValue)) { TempDataRow.SetData(TempAttr.AttrId, sDefaultAttrValue); } } } } }
/// <summary> /// /// This method will merge the contents of this Group with the one provided. /// /// NOTE: A true merge happens only between two instances of a group with one row. The functionality /// to merge other groups has not yet been truly implemented. /// /// <param name="ThatProductGroup">The Group that should merge with this one</param> /// <returns>None</returns> /// </summary> public void Merge(WonkaPrdGroup ThatProductGroup) { if (this.MasterGroup.GroupId == ThatProductGroup.MasterGroup.GroupId) { if ((this.GetRowCount() == 1) && (ThatProductGroup.GetRowCount() == 1)) { if (ThatProductGroup.GetRowCount() > 0) { if (this.GetRowCount() <= 0) { AppendRow(); } WonkaPrdGroupDataRow ThisRow = this.DataRowVector[0]; WonkaPrdGroupDataRow ThatRow = ThatProductGroup.DataRowVector[0]; ThisRow.Merge(ThatRow); } } else if (ThatProductGroup.GetRowCount() > 0) { this.SetData(ThatProductGroup); } } else { throw new Exception("ERROR! Attempting to merge two Groups of different sizes!"); } }
/// <summary> /// /// This method will provide the ProductGroup inside this Product, if one has already /// been instantiated with values. If not, it will create a new empty one and place it /// inside the collection. /// /// <param name="pnGroupId">The ID of the Group that we are interested in retrieving</param> /// <returns>The ProductGroup that we want to retrieve from this Product</returns> /// </summary> public WonkaPrdGroup GetProductGroup(int pnGroupId) { WonkaPrdGroup SoughtGroup = null; if (HasProductGroup(pnGroupId)) { SoughtGroup = this.ProductGroups[pnGroupId]; } else { if (WonkaRefEnvironment.GetInstance().DoesGroupExist(pnGroupId)) { this.ProductGroups[pnGroupId] = new WonkaPrdGroup(WonkaRefEnvironment.GetInstance().GetGroupByGroupId(pnGroupId)); return(this.ProductGroups[pnGroupId]); } else { throw new Exception("ERROR! Requested Group ID (" + pnGroupId + ") does not exist."); } } return(SoughtGroup); }
/// <summary> /// /// This method will compare two Groups to see if they are equal, but it will /// only compare those Attributes mentioned in the target Field. /// /// <param name="poThatGroup">The group being compared against (usually representing old data from persistence/storage)</param> /// <param name="poTargetField">The Field that has the Attribute list of interest</param> /// <returns>Bool that indicates whether or not the two Groups are equal</returns> /// </summary> public bool Equals(WonkaPrdGroup poThatGroup, WonkaRefField poTargetField) { Dictionary <int, string> ThisGroupAttrValues = new Dictionary <int, string>(); Dictionary <int, string> ThatGroupAttrValues = new Dictionary <int, string>(); return(Equals(poThatGroup, poTargetField, ThisGroupAttrValues, ThatGroupAttrValues)); }
public WonkaPrdGroup(WonkaPrdGroup poOriginalGroup) : this(poOriginalGroup.MasterGroup) { this.DataRowVector.AddRange(poOriginalGroup.DataRowVector); this.Modified = poOriginalGroup.Modified; this.OldDataFound = poOriginalGroup.OldDataFound; this.ProperlySequenced = poOriginalGroup.ProperlySequenced; }
public WonkaPrdGroupEnumerator(WonkaPrdGroup poGroup) { if (poGroup == null) { throw new Exception("ERROR! Group provided is null."); } moGroup = poGroup; }
/// <summary> /// /// This method will replace the contents of its current DataRows with the contents of the provided Group. /// /// <param name="poOriginalCopy">The Group from which we are going to copy the DataRows</param> /// <returns>None</returns> /// </summary> public void SetData(WonkaPrdGroup poOriginalCopy) { this.DeleteRows(); foreach (WonkaPrdGroupDataRow ThatDataRow in poOriginalCopy.DataRowVector) { AppendRow(new WonkaPrdGroupDataRow(ThatDataRow)); } }
/// <summary> /// /// This method will compare two Groups to see if they are equal, but it will /// only compare those Attributes mentioned in the target Field. /// /// NOTE: The auditing containers 'poThisAttrValues' and 'poThatAttrValues' will only /// work correctly with a group that only has one row. /// /// <param name="poThatGroup">The group being compared against (usually representing old data from the persistence/storage)</param> /// <param name="poTargetField">The Field that has the Attribute list of interest</param> /// <param name="poThisAttrValues">Storage for the values different from "this" group</param> /// <param name="poThatAttrValues">Storage for the values different from "that" group</param> /// <returns>Bool that indicates whether or not the two Groups are equal</returns> /// </summary> public bool Equals(WonkaPrdGroup poThatGroup, WonkaRefField poTargetField, Dictionary <int, string> poThisAttrValues, Dictionary <int, string> poThatAttrValues) { HashSet <int> IgnoreAttrIds = new HashSet <int>(); return(Equals(poThatGroup, poTargetField, IgnoreAttrIds, poThisAttrValues, poThatAttrValues)); }
/// <summary> /// /// This method will update the contents of a row (at index 'pnRowIndex') with the values from the supplied DataRow /// (via matching on the key), but only for the Attributes of a given Field. In addition, if any Attribute inside /// the updated Field has an associated AttrModDt, we will set that Attribute with the timestamp of CurrTimeStamp. /// /// NOTE: This code assumes that only 1 AttrModDt will be updated per call of updateField(...) /// /// <param name="poThatGroup">The Group that we are using to update this one</param> /// <param name="poTargetField">The Field that possesses the Attribute list of interest</param> /// <param name="psCurrTimeStamp">The current Timestamp that we will use to set any associated AttrModDdt</param> /// <returns>The AttrID of the AttrModDt which has been updated with the CurrTimeStamp</returns> /// </summary> public int UpdateField(WonkaPrdGroup poThatGroup, WonkaRefField poTargetField, string psCurrTimeStamp = null) { int nUpdatedModDtAttrId = 0; HashSet <int> FieldAttrIds = WonkaRefEnvironment.GetInstance().GetAttrIdsByFieldId(poTargetField.FieldId); string sTimeStamp = (!String.IsNullOrEmpty(psCurrTimeStamp)) ? psCurrTimeStamp : DateTime.Now.ToString("yyyyMMddHHmmss"); foreach (WonkaPrdGroupDataRow ThatRow in poThatGroup) { WonkaPrdGroupDataRow ThisRow = (this.GetRowIndex(ThatRow.GetKey()) >= 0) ? this.GetRow(ThatRow.GetKey()) : AppendRow(); foreach (int nTempAttrId in FieldAttrIds) { string sThatValue = ThatRow[nTempAttrId]; if (!String.IsNullOrEmpty(sThatValue)) { WonkaRefAttr TempAttr = WonkaRefEnvironment.GetInstance().GetAttributeByAttrId(nTempAttrId); ThisRow[nTempAttrId] = sThatValue; if (TempAttr.AttrModDtFlag) { try { WonkaRefAttr TempAttrModDt = WonkaRefEnvironment.GetInstance().GetAttributeByAttrName(TempAttr.AttrModDt); string sThatAttrModDtValue = ThatRow[TempAttrModDt.AttrId]; // NOTE: We will only use the CurrentTimestamp if there isn't already a timestamp value // in the provided DataRow of ThatGroup if (String.IsNullOrEmpty(sThatAttrModDtValue)) { ThisRow[TempAttrModDt.AttrId] = sTimeStamp; if (nUpdatedModDtAttrId == 0) { nUpdatedModDtAttrId = TempAttrModDt.AttrId; } } } catch (Exception ex) { throw new Exception("ERROR! Cannot set the ATTR_MOD_DT sibling (" + TempAttr.AttrModDt + ") for ATTRIBUTE (" + TempAttr.AttrName + ")."); } } } } } return(nUpdatedModDtAttrId); }
/// <summary> /// /// This method will update a particular ProductGroup of this Product with the one provided. /// /// <param name="poThatProductGroup">The ProductGroup from which we will copy our sought data</param> /// <param name="pbMergeFlag">Indicator of whether the provided data should completely overlay or merge with the contents of this ProductGroup</param> /// <returns>None</returns> /// </summary> public void Update(WonkaPrdGroup poThatProductGroup, bool pbMergeFlag) { WonkaPrdGroup ThisPrdGroup = this.GetProductGroup(poThatProductGroup.GroupId); if (pbMergeFlag) { ThisPrdGroup.Merge(poThatProductGroup); } else { ThisPrdGroup = poThatProductGroup; } }
/// <summary> /// /// This method will compare two Groups to see if they are equal, but it will /// only compare those Attributes mentioned in the target Field. /// /// NOTE: The auditing containers 'poThisAttrValues' and 'poThatAttrValues' will only /// work correctly with a group that only has one row. /// /// <param name="poThatGroup">The group being compared against (usually representing old data from the DB)</param> /// <param name="poTargetField">The Field that has the Attribute list of interest</param> /// <param name="poIgnoreAttrIds">The list of Attributes that should be ignored when comparisons are done</param> /// <param name="poThisAttrValues">Storage for the values different from "this" group</param> /// <param name="poThatAttrValues">Storage for the values different from "that" group</param> /// <returns>Bool that indicates whether or not the two Groups are equal</returns> /// </summary> public bool Equals(WonkaPrdGroup poThatGroup, WonkaRefField poTargetField, HashSet <int> poIgnoreAttrIds, Dictionary <int, string> poNewAttrValues, Dictionary <int, string> poOldAttrValues) { bool bResult = true; foreach (WonkaPrdGroupDataRow ThisRow in this.DataRowVector) { int nThatRowIndex = poThatGroup.GetRowIndex(ThisRow.GetKey()); if (nThatRowIndex != -1) { WonkaPrdGroupDataRow ThatRow = poThatGroup[nThatRowIndex]; HashSet <int> FieldAttrIds = WonkaRefEnvironment.GetInstance().GetAttrIdsByFieldId(poTargetField.FieldId); foreach (int nAttrId in FieldAttrIds) { WonkaRefAttr TempAttr = WonkaRefEnvironment.GetInstance().GetAttributeByAttrId(nAttrId); if (poIgnoreAttrIds.Contains(nAttrId)) { continue; } if (poTargetField.MergeNullAttrFlag || !String.IsNullOrEmpty(ThisRow[nAttrId])) { string sThisValue = ThisRow[nAttrId]; string sThatValue = ThatRow[nAttrId]; if (sThisValue != sThatValue) { // NOTE: Need to record these values, maybe for auditing if (TempAttr.IsAudited) { poNewAttrValues[TempAttr.AttrId] = sThisValue; poOldAttrValues[TempAttr.AttrId] = sThatValue; } bResult = Compare(TempAttr, sThisValue, sThatValue); } } } } } return(bResult); }
/// <summary> /// /// This method will seek the primary row (i.e., usually the first row) of a ProductGroup and then /// return the value for the Attribute in that row. If the ProductGroup is sequenced, we will /// look for the row with the 'group_seq' equal to 1; if it's not, we will just take the first row. /// /// <param name="pnGroupId">The ID of the Group that we are interested in</param> /// <param name="pnAttrId">The ID of the Attribute that we are interested in</param> /// <returns>The value of the Attribute for the Group's primary row</returns> /// </summary> public string GetPrimaryAttributeData(int pnGroupId, int pnAttrId) { string sAttrValue = null; WonkaPrdGroup TargetGroup = this.GetProductGroup(pnGroupId); if (TargetGroup.DataRowVector.Count > 0) { if (TargetGroup.MasterGroup.IsSequenced) { int nSeqAttrId = WonkaRefEnvironment.GetInstance().GetGroupSeqAttrId(pnGroupId); WonkaPrdGroupDataRow TargetDataRow = null; if (TargetGroup.DataRowVector.Any(x => x.ContainsKey(nSeqAttrId) && x[nSeqAttrId] == "1")) { TargetDataRow = TargetGroup.DataRowVector.Where(x => x.ContainsKey(nSeqAttrId) && x[nSeqAttrId] == "1").FirstOrDefault(); } else { TargetDataRow = TargetGroup[0]; } if (TargetDataRow.ContainsKey(pnAttrId)) { sAttrValue = TargetDataRow[pnAttrId]; } } else { WonkaPrdGroupDataRow TargetDataRow = TargetGroup[0]; if (TargetDataRow.ContainsKey(pnAttrId)) { sAttrValue = TargetDataRow[pnAttrId]; } } } return(sAttrValue); }
/// <summary> /// /// This method will compare two Groups to see if they are equal. It will compare /// them by finding a corresponding DataRow within ThisGroup and ThatGroup, based /// on the key. /// /// NOTE: This Group (i.e., the left-hand data row) usually represents incoming/new data /// /// NOTE: Currently, it doesn't compare them exactly. It just ensures that /// the contents of 'r1' are the same in 'r2', implying that 'r2' can be a /// superset of 'r1'. /// /// <param name="ThatGroup">The right-hand data row (usually representing old data from persistence/storage)</param> /// <returns>Bool that indicates whether or not the two Groups are equal</returns> public bool Equals(WonkaPrdGroup poThatGroup) { foreach (WonkaPrdGroupDataRow ThisRow in this) { int nThatRowIndex = poThatGroup.GetRowIndex(ThisRow.GetKey()); if (nThatRowIndex != -1) { if (ThisRow != poThatGroup.GetRow(nThatRowIndex)) { return(false); } } else { return(false); } } return(true); }
/// <summary> /// /// This method will assign the Attribute values for a new DataRow /// created for their respective Group. /// /// <param name="poProduct">The Product that we are assigning these Attribute values</param> /// <param name="poAttrValues">The Attribute values that we are going to set inside the provided Product</param> /// <returns>None</returns> /// </summary> public static void PopulateProductGroup(WonkaProduct poProduct, int pnGroupId, Dictionary <int, string> poAttrValues) { WonkaPrdGroup TempPrdGroup = poProduct.ProductGroups[pnGroupId]; WonkaPrdGroupDataRow TempDataRow = TempPrdGroup.AppendRow(); var iAttrValueEnum = poAttrValues.GetEnumerator(); while (iAttrValueEnum.MoveNext()) { int nAttrId = iAttrValueEnum.Current.Key; string sAttrValue = iAttrValueEnum.Current.Value; WonkaRefAttr TempAttribute = WonkaRefEnvironment.GetInstance().GetAttributeByAttrId(nAttrId); if (TempAttribute.GroupId != pnGroupId) { continue; } TempDataRow.SetData(nAttrId, sAttrValue); } }
/// <summary> /// /// This method will assign the Attribute values specifically to the first DataRow /// of their respective Group. /// /// NOTE: This method will nullify Attributes only for the first DataRow of the Group. /// /// <param name="poProduct">The Product that we are assigning these Attribute values</param> /// <param name="poAttrValues">The Attribute values that we are going to set inside the provided Product</param> /// <returns>None</returns> /// </summary> public static void PopulateProduct(WonkaProduct poProduct, Dictionary <int, string> poAttrValues) { var iAttrValueEnum = poAttrValues.GetEnumerator(); while (iAttrValueEnum.MoveNext()) { int nAttrId = iAttrValueEnum.Current.Key; string sAttrValue = iAttrValueEnum.Current.Value; WonkaRefAttr TempAttribute = WonkaRefEnvironment.GetInstance().GetAttributeByAttrId(nAttrId); WonkaPrdGroup TempPrdGroup = poProduct.ProductGroups[TempAttribute.GroupId]; if (TempPrdGroup.GetRowCount() <= 0) { TempPrdGroup.AppendRow(); } WonkaPrdGroupDataRow GrpDataRow = TempPrdGroup.GetRow(0); GrpDataRow.SetData(nAttrId, sAttrValue); } }
/// <summary> /// /// This method will iterate through all of the data in the contained groups and detect whether /// any of them are not valid according to the designated type for that Attribute. /// /// <param name="poErrors">The list to which we will add any errors concerning the validation of types</param> /// <returns>Indicates whether or not there any errors with validating types</returns> /// </summary> public bool ValidateTypes(List <WonkaProductError> poErrors) { WonkaRefEnvironment RefEnv = WonkaRefEnvironment.GetInstance(); bool bResult = true; foreach (int nGrpId in this.ProductGroups.Keys) { WonkaPrdGroup TempGroup = ProductGroups[nGrpId]; foreach (WonkaPrdGroupDataRow TempDataRow in TempGroup) { foreach (int nAttrId in TempDataRow.Keys) { string sAttrValue = TempDataRow[nAttrId]; if (!String.IsNullOrEmpty(sAttrValue)) { WonkaRefAttr TempAttr = RefEnv.GetAttributeByAttrId(nAttrId); if (TempAttr.IsDecimal) { try { Decimal dValue = Convert.ToDecimal(sAttrValue); } catch (Exception ex) { poErrors.Add(new WonkaProductError() { AttrName = TempAttr.AttrName, ErrorMessage = "ERROR! Value(" + sAttrValue + ") is not a valid decimal!" }); } } else if (TempAttr.IsNumeric) { try { long nValue = Convert.ToInt64(sAttrValue); } catch (Exception ex) { poErrors.Add(new WonkaProductError() { AttrName = TempAttr.AttrName, ErrorMessage = "ERROR! Value(" + sAttrValue + ") is not a valid number!" }); } } else if (TempAttr.IsDate) { try { DateTime dtValue = DateTime.Parse(sAttrValue); } catch (Exception ex) { poErrors.Add(new WonkaProductError() { AttrName = TempAttr.AttrName, ErrorMessage = "ERROR! Value(" + sAttrValue + ") is not a valid date!" }); } } } } } } return(bResult); }