/// <summary>
/// This method will set all of the Attributes (for the target Field) within this Row to
/// those in the provided one.
/// </summary>
/// <param name="poOriginal">The DataRow that we are copying all of the Attribute values from</param>
/// <param name="poField">The subset of Attributes that we are targeting for the copy</param>
/// <returns>None</returns>
public void SetData(WonkaPrdGroupDataRow poOriginal, WonkaRefField poField)
{
foreach (int TmpAttrId in poField.AttrIds)
{
this[TmpAttrId] = poOriginal[TmpAttrId];
}
}
/// <summary>
///
/// This method will return the sought ProductField of this Product, if one is already present.
/// If it is not present, it will create one by default and return it after inserting into
/// our collection.
///
/// <param name="poField">The Field representing the ProductField that we want to retrieve</param>
/// <returns>The ProductField that we want to retrieve from this Product</returns>
/// </summary>
public WonkaProductField GetProductField(WonkaRefField poField)
{
WonkaProductField SoughtField = null;
if (ProductFieldIndex.Keys.Contains(poField.FieldId))
{
SoughtField = ProductFieldIndex[poField.FieldId];
}
else if (WonkaRefEnvironment.GetInstance().DoesFieldExist(poField.FieldId))
{
ProductFieldIndex[poField.FieldId] = new WonkaProductField();
SoughtField = ProductFieldIndex[poField.FieldId];
SoughtField.ProductId = this.ProductId;
SoughtField.FieldId = poField.FieldId;
SoughtField.LockCd = "N";
SoughtField.LastTouchedSourceId =
(this.OwnerSourceIds != null) && (this.OwnerSourceIds.Count > 0) ? this.OwnerSourceIds.ElementAt(0) : 0;
}
else
{
throw new Exception("ERROR! WonkaProduct::getProductField(const WonkaRefField&) : " +
"Requested field does not exist: (" + poField.FieldName + ").");
}
return(SoughtField);
}
/// <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));
}
/// <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 compare two DataRows to see if their Fields are equal.
///
/// NOTE: Currently, it doesn't compare them exactly. It just ensures that
/// the contents of the Field in 'r1' are the same in 'r2', implying that
/// the'r2' Field can be a superset of 'r1'.
///
/// </summary>
/// <param name="poThatDataRow">The data row that this one is being compared to</param>
/// <returns>Bool that indicates whether or not the two DataRows are equal</returns>
public bool Equals(WonkaPrdGroupDataRow poThatDataRow, WonkaRefField poField)
{
foreach (int nAttrId in poField.AttrIds)
{
if (this[nAttrId] != poThatDataRow[nAttrId])
{
return(false);
}
}
return(true);
}
/// <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 detect if this Data Row is null (i.e., empty with no values present)
/// with respect to those Attributes in the indicated Field.
///
/// </summary>
/// <param name="poField">The Field whose Attributes are being inspected</param>
/// <returns>Bool whether the row is empty (i.e., null) in terms of the Attributes for the Field</returns>
public bool IsNull(WonkaRefField poField)
{
foreach (int nAttrId in poField.AttrIds)
{
string sValue = this[nAttrId];
if (sValue.Length > 0)
{
return(false);
}
}
return(true);
}
public List <WonkaRefField> GetFieldCache()
{
List <WonkaRefField> FieldCache = new List <WonkaRefField>();
XmlSerializer FieldSerializer = new XmlSerializer(typeof(WonkaRefField));
XmlNodeList FieldNodeList = moXmlDoc.GetElementsByTagName("Field");
foreach (XmlNode FieldNode in FieldNodeList)
{
WonkaRefField TempField = (WonkaRefField)FieldSerializer.Deserialize(new StringReader(FieldNode.OuterXml));
FieldCache.Add(TempField);
}
return(FieldCache);
}
/// <summary>
///
/// This method will detect if all DataRows contained in this Group are considered 'null' (i.e., empty of values),
/// but only for those Attributes mentioned within the target Field.
///
/// <param name="poField">The target Field with the list of Attributes on which we are focused</param>
/// <param name="pbIgnoreDeletedRows">Indicates whether or not Marked-as-Delete rows should be ignored</param>
/// <returns>Bool that indicates if there are any rows present inside the Group that are not null</returns>
///
/// </summary>
public bool IsNull(WonkaRefField poField, bool pbIgnoreDeletedRows = true)
{
bool bResult = true;
if (GetRowCount() == 0)
{
return(bResult);
}
int nGrpSeqAttrId = -1;
HashSet <int> FieldAttrIds = WonkaRefEnvironment.GetInstance().GetAttrIdsByFieldId(poField.FieldId);
if (this.MasterGroup.IsSequenced)
{
nGrpSeqAttrId = WonkaRefEnvironment.GetInstance().GetGroupSeqAttrId(MasterGroup.GroupId);
}
foreach (WonkaPrdGroupDataRow TempDataRow in DataRowVector)
{
if (pbIgnoreDeletedRows)
{
if ((nGrpSeqAttrId >= 0) && (TempDataRow[nGrpSeqAttrId] == "0"))
{
continue;
}
}
foreach (int nAttrId in FieldAttrIds)
{
string sTempValue = TempDataRow[nAttrId];
if (!String.IsNullOrEmpty(sTempValue))
{
return(false);
}
}
}
return(bResult);
}
public void AddField(WonkaRefField poNewField)
{
FieldCollection.Add(poNewField);
}
/// <summary>
///
/// This method will detect whether or not this Product already has an instance of the identified
/// ProductField
///
/// <param name="poField">The Field indicating the ProductField that we are interested in</param>
/// <returns>Indicator of whether or not an instance of that ProductField has been created within this Product</returns>
/// </summary>
public bool HasProductField(WonkaRefField poField)
{
return(this.ProductFieldIndex.Keys.Contains(poField.FieldId));
}
public IMetadataRetrievable ImportSource(string psDatabaseTable, ObjectContext poDbContext)
{
WonkaBreImportSource NewImportSource = new WonkaBreImportSource();
HashSet <string> KeyColNames = new HashSet <string>();
if (!String.IsNullOrEmpty(psDatabaseTable) && (poDbContext != null))
{
if (moCachedImports.ContainsKey(psDatabaseTable))
{
return(moCachedImports[psDatabaseTable]);
}
var tables =
poDbContext.MetadataWorkspace.GetItems(DataSpace.CSpace).Where(m => m.BuiltInTypeKind == BuiltInTypeKind.EntityType);
foreach (var TmpTable in tables)
{
EntityType TmpEntityType = (EntityType)TmpTable;
if (TmpEntityType.Name == psDatabaseTable)
{
var KeyCols = TmpEntityType.KeyMembers;
foreach (var KeyCol in KeyCols)
{
KeyColNames.Add(KeyCol.Name);
}
break;
}
}
var columns =
from meta in poDbContext.MetadataWorkspace.GetItems(DataSpace.CSpace).Where(m => m.BuiltInTypeKind == BuiltInTypeKind.EntityType)
from p in (meta as EntityType).Properties.Where(p => p.DeclaringType.Name == psDatabaseTable)
select new
{
colName = p.Name,
colType = p.TypeUsage.EdmType,
doc = p.Documentation,
maxLength = p.MaxLength,
precision = p.Precision,
scale = p.Scale,
defValue = p.DefaultValue,
props = p.MetadataProperties
};
foreach (var TmpCol in columns)
{
string sTmpColName = TmpCol.colName;
var Props = TmpCol.props;
WonkaRefAttr TmpWonkaAttr = new WonkaRefAttr();
TmpWonkaAttr.AttrId = GenerateNewAttrId();
TmpWonkaAttr.AttrName = sTmpColName;
TmpWonkaAttr.ColName = sTmpColName;
TmpWonkaAttr.TabName = psDatabaseTable;
TmpWonkaAttr.DefaultValue = Convert.ToString(TmpCol.defValue);
TmpWonkaAttr.Description = (TmpCol.doc != null) ? TmpCol.doc.LongDescription : "";
TmpWonkaAttr.IsDate = IsTypeDate(TmpCol.colType);
TmpWonkaAttr.IsNumeric = IsTypeNumeric(TmpCol.colType);
TmpWonkaAttr.IsDecimal = IsTypeDecimal(TmpCol.colType);
if (TmpWonkaAttr.IsNumeric || TmpWonkaAttr.IsDecimal)
{
TmpWonkaAttr.Precision = (int)((TmpCol.precision != null) ? TmpCol.precision : 0);
TmpWonkaAttr.Scale = (int)((TmpCol.scale != null) ? TmpCol.scale : 0);
}
TmpWonkaAttr.MaxLength = (TmpCol.maxLength != null) ? (int)TmpCol.maxLength : 0;
TmpWonkaAttr.FieldId = TmpWonkaAttr.AttrId + 1000;
TmpWonkaAttr.GroupId = CONST_DEFAULT_GROUP_ID;
TmpWonkaAttr.IsAudited = true;
TmpWonkaAttr.IsKey = KeyColNames.Contains(TmpWonkaAttr.AttrName);
NewImportSource.AddAttribute(TmpWonkaAttr);
}
if (NewImportSource.GetAttrCache().Count <= 0)
{
throw new WonkaBreException(0, 0, "ERROR! Could not import the schema because the Reader's field count was zero.");
}
WonkaRefGroup NewImportGroup = new WonkaRefGroup();
NewImportGroup.GroupId = CONST_DEFAULT_GROUP_ID;
NewImportGroup.GroupName = psDatabaseTable;
NewImportGroup.KeyTabCols = KeyColNames;
NewImportGroup.ProductTabName = psDatabaseTable;
NewImportSource.AddGroup(NewImportGroup);
WonkaRefSource GuestSource = new WonkaRefSource();
GuestSource.SourceId = 1;
GuestSource.SourceName = "Guest";
GuestSource.Status = "Active";
NewImportSource.AddSource(GuestSource);
foreach (WonkaRefAttr TempAttr in NewImportSource.GetAttrCache())
{
WonkaRefField NewImportField = new WonkaRefField();
NewImportField.FieldId = TempAttr.FieldId;
NewImportField.FieldName = TempAttr.AttrName;
NewImportField.Description = TempAttr.Description;
NewImportField.GroupId = CONST_DEFAULT_GROUP_ID;
NewImportField.DisplayName = TempAttr.AttrName;
NewImportField.AttrIds.Add(TempAttr.AttrId);
NewImportSource.AddField(NewImportField);
WonkaRefSourceField NewImportSrcFld = new WonkaRefSourceField();
NewImportSrcFld.SourceFieldId = 10000 + NewImportField.FieldId;
NewImportSrcFld.SourceId = 1;
NewImportSrcFld.FieldId = NewImportField.FieldId;
NewImportSrcFld.SecurityLevel = CONST_SEC_LEVEL_READ;
NewImportSource.AddSourceField(NewImportSrcFld);
}
}
else
{
throw new WonkaBreException(0, 0, "ERROR! Could not import the schema for the database table.");
}
PopulateDefaults();
return(NewImportSource);
}
