/// <summary> /// Update the debt class with new information from another debt class. /// </summary> /// <param name="entity"></param> public override void Update(GuardianObject entity) { DebtClass source = entity as DebtClass; if (!this.Modified && this.DebtClassId == source.DebtClassId) { this.DebtRuleId = source.DebtRuleId; this.Address1 = source.Address1; this.Address2 = source.Address2; this.BankRoutingNumber = source.BankRoutingNumber; this.BankAccountNumber = source.BankAccountNumber; this.City = source.City; this.CompanyName = source.CompanyName; this.ContactName = source.ContactName; this.Department = source.Department; this.Email = source.Email; this.Fax = source.Fax; this.ForBenefitOf = source.ForBenefitOf; this.Phone = source.Phone; this.Province = source.Province; this.PostalCode = source.PostalCode; this.SettlementTemplate = source.SettlementTemplate; this.Modified = false; } this.rowVersion = source.RowVersion; }
/// <summary> /// Populate the debt rule information in the debt rule tab. /// </summary> protected override void Populate(Entity entity) { base.Populate(entity); try { lock (DataModel.SyncRoot) { DebtClass debtClass = entity as DebtClass; List <DebtRule> rules = null; DebtRule currentRule = null; Boolean enabled = true; Boolean inherited = true; // Only populate the window if the entity still exists. (If it doesn't, it's been deleted since the window was opened.) if (entity != null) { rules = GetAvailableRules(entity); currentRule = debtClass.GetDebtRule(); inherited = debtClass.DebtRuleId == null; } else { enabled = false; } this.Dispatcher.BeginInvoke(DispatcherPriority.Normal, new populate(this.Populate), enabled, rules, currentRule, inherited); } } catch { } }
/// <summary> /// Get a list of the rules available to this debt class. /// </summary> /// <returns>A list of the available rules.</returns> private List <DebtRule> GetAvailableRules(Entity entity) { List <DebtRule> rules = new List <DebtRule>(); DebtClassRow debtClass = DataModel.DebtClass.DebtClassKey.Find(entity.EntityId); DebtClassRow parent = this.RetrieveParent(entity.EntityId); if (parent != null) { DebtRule inherited = DebtClass.GetDebtRule(parent.DebtClassId, entity.TypeId); inherited.Name = "<inherit from parent>"; inherited.DebtRuleId = null; rules.Add(inherited); } while (debtClass != null) { var maps = DataModel.DebtRuleMap.Where(row => row.DebtClassId == debtClass.DebtClassId); foreach (DebtRuleMapRow map in maps) { if (map.DebtRuleRow.Name != "") { rules.Add(new DebtRule(map.DebtRuleRow)); } } debtClass = this.RetrieveParent(debtClass.DebtClassId); } return(rules); }
/// <summary> /// Find the effective (inherited) value of a column in a debt class. /// </summary> /// <typeparam name="T">The type of the column.</typeparam> /// <param name="debtClassId">The DebtClassId of the debt class in question.</param> /// <param name="field">The column to retrieve.</param> /// <returns>Effective value of the indicated column, eg. the value in the debt class with the indicated ID, or, if that debt class has no /// value for the column, the value of the column in nearest ancestor debt class that has a value for that column. If no value can be found, /// returns null.</returns> private static object FindEffectiveField <T>(Guid debtClassId, DataColumn field) { object value = null; lock (DataModel.SyncRoot) { DebtClassRow parent = DebtClass.FindParentWithField(debtClassId, field); if (parent != null) { value = (object)parent.Field <T>(field); } } return(value); }
/// <summary> /// Find the debt rule assocatiated with a debt class of a particular type. This function locks the DataModel. /// </summary> /// <param name="debtClassId">The DebtClassId of the debt class.</param> /// <param name="typeId">The TypeId of the debt class.</param> /// <returns>The debt rule. If none can be found either in the debt class or its ancestors, null is returned.</returns> public static DebtRule GetDebtRule(Guid debtClassId, Guid typeId) { DebtRule rule = null; lock (DataModel.SyncRoot) { DebtClassRow parent = DebtClass.FindParentWithField(debtClassId, DataModel.DebtClass.DebtRuleIdColumn); if (parent != null) { rule = new DebtRule(parent.DebtRuleRow); } } return(rule); }
/// <summary> /// Background thread that initializes the status bar. /// </summary> protected override void Populate() { // Make sure the common properties are updated before addressing the extended properties. base.Populate(); try { Boolean entityDeleted = false; decimal matchedDollars = 0m; decimal totalDollars = 0m; int totalRecords = 0; int matchedRecords = 0; Guid blotterId = this.entityId; DebtRule rule = null; lock (DataModel.SyncRoot) { EntityRow entityRow = DataModel.Entity.EntityKey.Find(blotterId); if (entityRow != null) { CountChildMoney(entityRow, ref matchedDollars, ref totalDollars, ref totalRecords, ref matchedRecords); rule = DebtClass.GetDebtRule(this.entityId, entityRow.TypeId); } else { entityDeleted = true; } } if (!entityDeleted && rule != null) { this.Dispatcher.BeginInvoke( DispatcherPriority.Normal, new SetStatusBarDelegate(Populate), Decimal.ToDouble(matchedDollars), Decimal.ToDouble(totalDollars), Decimal.ToDouble(rule.SettlementValue), totalRecords, matchedRecords); } } catch { // If we fail, we'll just keep up the old status bar. } }
/// <summary> /// Get the effective (inherited) value of PostalCode. /// </summary> /// <returns>If PostalCode is non-null, returns PostalCode, otherwise returns the PostalCode of the closest ancestor whose PostalCode is non-null.</returns> public string GetEffectivePostalCode() { return(DebtClass.FindEffectiveField <string>(this.DebtClassId, DataModel.DebtClass.PostalCodeColumn) as string); }
/// <summary> /// Get the effective (inherited) value of State. /// </summary> /// <returns>If State is non-null, returns State, otherwise returns the State of the closest ancestor whose State is non-null.</returns> public string GetEffectiveState() { return(DebtClass.FindEffectiveField <string>(this.DebtClassId, DataModel.DebtClass.ProvinceIdColumn) as string); }
/// <summary> /// Get the effective (inherited) value of ForBenefitOf. /// </summary> /// <returns>If ForBenefitOf is non-null, returns ForBenefitOf, otherwise returns the ForBenefitOf of the closest ancestor whose ForBenefitOf /// is non-null.</returns> public string GetEffectiveForBenefitOf() { return(DebtClass.FindEffectiveField <string>(this.DebtClassId, DataModel.DebtClass.ForBenefitOfColumn) as string); }
/// <summary> /// Get the effective (inherited) value of Email. /// </summary> /// <returns>If Email is non-null, returns Email, otherwise returns the Email of the closest ancestor whose Email is non-null.</returns> public string GetEffectiveEmail() { return(DebtClass.FindEffectiveField <string>(this.DebtClassId, DataModel.DebtClass.EmailColumn) as string); }
/// <summary> /// Get the effective (inherited) value of Department. /// </summary> /// <returns>If Department is non-null, returns Department, otherwise returns the Department of the closest ancestor whose Department is /// non-null.</returns> public string GetEffectiveDepartment() { return(DebtClass.FindEffectiveField <string>(this.DebtClassId, DataModel.DebtClass.DepartmentColumn) as string); }
/// <summary> /// Get the effective (inherited) value of ContactName. /// </summary> /// <returns>If ContactName is non-null, returns ContactName, otherwise returns the ContactName of the closest ancestor whose ContactName is /// non-null.</returns> public string GetEffectiveContactName() { return(DebtClass.FindEffectiveField <string>(this.DebtClassId, DataModel.DebtClass.ContactNameColumn) as string); }
/// <summary> /// Get the effective (inherited) value of BankRoutingNumber. /// </summary> /// <returns>If BankRoutingNumber is non-null, returns BankRoutingNumber, otherwise returns the BankRoutingNumber of the closest ancestor /// whose BankRoutingNumber is non-null.</returns> public string GetEffectiveBankRoutingNumber() { return(DebtClass.FindEffectiveField <string>(this.DebtClassId, DataModel.DebtClass.BankRoutingNumberColumn) as string); }
/// <summary> /// Get the effective (inherited) value of Address2. /// </summary> /// <returns>If Address2 is non-null, returns Address2, otherwise returns the Address2 of the closest ancestor whose Address2 is /// non-null.</returns> public string GetEffectiveAddress2() { return(DebtClass.FindEffectiveField <string>(this.DebtClassId, DataModel.DebtClass.Address2Column) as string); }
/// <summary> /// Get the debt rule used for this debt class. This function locks the DataModel. /// </summary> /// <returns>The debt rule. If none can be found either in the debt class or its ancestors, null is returned.</returns> public DebtRule GetDebtRule() { return(DebtClass.GetDebtRule(this.EntityId, this.TypeId)); }
/// <summary> /// Create a duplicate debt class. /// </summary> /// <param name="source">The original debt class.</param> public DebtClass(DebtClass source) : base(source) { this.Update(source); }