/// <summary>
/// 当实体的某个属性变更时，自动向父级实体的指定属性汇总。
/// </summary>
/// <param name="entity">实体对象</param>
/// <param name="changedPropertyArgs">实体属性变更时的参数</param>
/// <param name="toTreeParent">
/// 如果实体是树型对象，那么这个参数表明是否需要把值汇总到树中的父对象的同一个属性值上。
/// </param>
/// <param name="toParentProperty">
/// 指示需要把值汇总到组合父对象的哪一个属性上。这个属性只支持直接父对象，不支持多级父对象。
/// </param>
/// <threadsafety static="true" instance="true"/>
public static void AutoCollectAsChanged(
Entity entity, ManagedPropertyChangedEventArgs changedPropertyArgs,
bool toTreeParent = true,
IManagedProperty toParentProperty = null
)
{
if (toTreeParent)
{
var treeEntity = entity as ITreeEntity;
if (treeEntity.IsTreeParentLoaded && treeEntity.TreeParent != null)
{
CalculateCollectValue(treeEntity.TreeParent, changedPropertyArgs.Property, changedPropertyArgs);
//如果已经向树型父汇总，则不向父对象汇总，直接返回
return;
}
}
if (toParentProperty != null)
{
var parent = (entity as IEntity).FindParentEntity();
if (parent != null)
{
CalculateCollectValue(parent, toParentProperty, changedPropertyArgs);
}
}
}
protected virtual void OnStorageInDirectlyChanged(ManagedPropertyChangedEventArgs e)
{
if ((bool)e.NewValue)
{
this.StorageInStatus = OrderStorageInStatus.Completed;
}
}
private void OnTimeChanged(ManagedPropertyChangedEventArgs e)
{
if (e.Source == ManagedPropertyChangedSource.FromUIOperating)
{
this.TimeSpanType = TimeSpanType.Custom;
}
}
protected virtual void OnOrderChanged(ManagedPropertyChangedEventArgs e)
{
var value = e.NewValue as PurchaseOrder;
var children = this.StorageInItemList;
children.Clear();
if (value != null)
{
foreach (PurchaseOrderItem item in value.PurchaseOrderItemList)
{
if (item.AmountLeft > 0)
{
var siItem = new StorageInBillItem
{
Id = RafyEnvironment.NewLocalId(),
Product = item.Product,
Amount = item.AmountLeft,
UnitPrice = item.RawPrice
};
children.Add(siItem);
}
}
}
this.NotifyPropertyChanged(StorageInItemListProperty);
this.NotifyPropertyChanged(View_SupplierNameProperty);
}
/// <summary>
/// Id 变更后事件。
/// </summary>
/// <param name="e">The <see cref="ManagedPropertyChangedEventArgs" /> instance containing the event data.</param>
protected override void OnIdChanged(ManagedPropertyChangedEventArgs e)
{
this.ResetFastField(_idFast);
this.SyncIdToChildren();
base.OnIdChanged(e);
}
protected override void OnPropertyChanged(ManagedPropertyChangedEventArgs e)
{
if (e.Property == View_TotalPriceProperty)
{
this.RaiseRoutedEvent(PriceChangedEvent, e);
}
base.OnPropertyChanged(e);
}
protected virtual void OnTimeSpanTypeChanged(ManagedPropertyChangedEventArgs e)
{
var today = DateTime.Today;
switch ((TimeSpanType)e.NewValue)
{
case TimeSpanType.Today:
this.From = this.To = today;
break;
case TimeSpanType.Week:
var dayOfWeek = (int)today.DayOfWeek;
if (dayOfWeek == 0)
{
dayOfWeek = 7;
}
dayOfWeek--; //0-6
var monday = today.AddDays(-dayOfWeek);
this.From = monday;
this.To = monday.AddDays(6);
break;
case TimeSpanType.Month:
this.From = new DateTime(today.Year, today.Month, 1);
this.To = new DateTime(today.Year, today.Month, DateTime.DaysInMonth(today.Year, today.Month));
break;
case TimeSpanType.LastMonth:
this.From = today.AddDays(-30);
this.To = today;
break;
case TimeSpanType.Year:
this.From = new DateTime(today.Year, 1, 1);
this.To = new DateTime(today.Year, 12, DateTime.DaysInMonth(today.Year, 12));
break;
case TimeSpanType.All:
this.From = new DateTime(1800, 1, 1);
this.To = new DateTime(9999, 12, 31);
break;
case TimeSpanType.Custom:
//Custom 不需要走下面的逻辑。
return;
default:
break;
}
var to = this.To;
this.To = to.Add(new TimeSpan(23, 59, 59));
}
protected override void OnPropertyChanged(ManagedPropertyChangedEventArgs e)
{
base.OnPropertyChanged(e);
if (e.Property == AgeProperty)
{
if (e.Source == ManagedPropertyChangedSource.FromUIOperating)
{
this.AgeChangedInternally_UIOperating = this.Age;
}
}
}
protected virtual void OnAgeChanged(ManagedPropertyChangedEventArgs e)
{
var newValue = (int)e.NewValue;
if (e.Source == ManagedPropertyChangedSource.FromProperty)
{
this.AgeChangedInternally_Property = newValue;
}
this._ageSerailizable = newValue;
this._ageNonserailizable = newValue;
}
protected virtual void OnAllTimeChanged(ManagedPropertyChangedEventArgs e)
{
var parentTree = this.TreeParent;
if (parentTree != null)
{
this.RaiseRoutedEvent(AllTimeChangedTreeRoutedEvent, e);
}
else
{
this.RaiseRoutedEvent(AllTimeChangedParentRoutedEvent, e);
}
}
/// <summary>
/// 这个事件不可以屏敝，否则状态会出问题。
/// </summary>
/// <param name="e"></param>
protected override void OnPropertyChanged(ManagedPropertyChangedEventArgs e)
{
var meta = e.Property.DefaultMeta as IPropertyMetadata;
if (meta.AffectStatus)
{
this.MarkModifiedIfUnchanged();
this.NotifyIfInRedundancyPath(e.Property as IProperty);
}
base.OnPropertyChanged(e);
}
/// <summary>
/// 子类重写此方法实现 TreePId 属性变更逻辑。
/// </summary>
/// <param name="e">The <see cref="ManagedPropertyChangedEventArgs"/> instance containing the event data.</param>
/// <exception cref="System.InvalidOperationException"></exception>
protected virtual void OnTreePIdChanged(ManagedPropertyChangedEventArgs e)
{
var newValue = e.NewValue;
if (newValue != null)
{
RemoveFromParentList(true);
#region 重新加载 TreeIndex、TreeParent
//如果没有加载树的父节点，说明是外界直接设置的 TreePId。
//此时，需要加载父节点，并通过父节点来计算本节点的索引。
if (_treeParent == null || !_treeParent.Id.Equals(newValue))
{
var hasId = this.KeyProvider.HasId(newValue);
if (hasId)
{
//直接设置 TreeParent 属性，在 TreeParent 属性中会重新生成 TreeIndex。
var repo = this.GetRepository() as IRepositoryInternal;
//var count = repo.CountByTreePId(newValue);
//this.TreeIndex = repo.TreeIndexOption.CalculateCode()
//在查询父节点时，同时把父节点的一级子节点也查询出来，这样可以防止多次查询。
var tree = repo.GetByIdOrTreePId(newValue);
if (tree.Count == 0)
{
throw new InvalidOperationException(string.Format(
"设置 TreePId 失败：设置的 TreePId 的值是：{0}，在仓库中没有找到 Id 是这个值的节点。",
newValue
));
}
this.TreeParent = tree[0];
}
}
#endregion
}
else
{
/*********************** 代码块解释 *********************************
* 只需要简单地清空 _treeParent，而没有再重新整理 _treeParent 中子节点的索引。
* 原因：
* 1.如果只是获取单一实体，并设置它的 TreePId 为空。
* 那么保存到数据库中后，原 _treeParent 中的子节点会出现断码，但此时索引的顺序还是正确的。
* 2.另外，就算这里重新获取 _treeParent 并重新整理其下的索引，
* 但是应用层只是在保存单一实体，这些变更的索引也无法保存到数据库中，同样形成断码。
* 所以，
* 为了简单起见，这种情况就先容忍了。应用层为了保证不出现断码，应该尽量使用 TreeChildren 集合。
**********************************************************************/
_treeParent = null;
}
}
protected virtual void OnIsDefaultChanged(ManagedPropertyChangedEventArgs e)
{
//整个列表中只有一个默认仓库。
if (e.Source == ManagedPropertyChangedSource.FromUIOperating && (bool)e.NewValue)
{
var list = (this as IEntity).ParentList;
if (list != null)
{
foreach (Storage item in list)
{
if (item != this)
{
item.IsDefault = false;
}
}
}
}
}
/// <summary>
/// 在属性变更时，如果该属性在某个冗余路径中，则应该使用冗余更新策略。
/// </summary>
/// <param name="e"></param>
private void NotifyIfInRedundancyPath(ManagedPropertyChangedEventArgs e)
{
var property = e.Property as IProperty;
if (property.IsInRedundantPath)
{
var refProperty = property as IRefIdProperty;
if (refProperty != null)
{
foreach (var path in property.InRedundantPathes)
{
//如果该引用属性是首位引用属性，并且冗余属性就是声明在这个对象上的，则直接计算冗余值，更新对象的值。
if (path.RefPathes[0].Property == refProperty)
{
//在继承实体的情况下，引用属性声明在父类，而冗余属性声明在子类B中时，子类A中则有引用属性而无冗余属性。
if (path.Redundancy.Owner.IsInstanceOfType(this))
{
//如果是第一个，说明冗余属性和这个引用属性是在当前类型中声明的，
//此时，直接更新冗余属性的值。
object value = this.GetRedundancyValue(path);
this.SetProperty(path.Redundancy.Property, value);
}
else
{
//并不是本实体类的引用属性变更，不需要更新冗余属性。
//do nothing
}
}
else
{
//延迟到更新数据库行时，才更新其它表的冗余属性
this.UpdateRedundancies = true;
}
}
}
else
{
this.UpdateRedundancies = true;
}
}
}
private static void CalculateCollectValue(Entity entity, IManagedProperty property, ManagedPropertyChangedEventArgs args)
{
var distance = Convert.ToDouble(args.NewValue) - Convert.ToDouble(args.OldValue);
var oldValue = Convert.ToDouble(entity.GetProperty(property));
entity.SetProperty(property, oldValue + distance);
}
protected virtual void OnTestUserChanged(ManagedPropertyChangedEventArgs e)
{
this.TestUserChangedInternal = e.NewValue as TestUser;
}
protected virtual void OnTestUserIdChanged(ManagedPropertyChangedEventArgs e)
{
this.TestUserIdChangedInternal = (int)e.NewValue;
}
protected virtual void OnModuleACChanged(ManagedPropertyChangedEventArgs e)
{
var value = e.NewValue as ModuleAC;
this.ModuleName = value != null ? value.KeyLabel : null;
}
/// <summary>
/// Id 变更后事件。
/// </summary>
/// <param name="e">The <see cref="ManagedPropertyChangedEventArgs" /> instance containing the event data.</param>
protected virtual void OnIdChanged(ManagedPropertyChangedEventArgs e)
{
this.SyncIdToChildren();
}
protected override void OnAmountChanged(ManagedPropertyChangedEventArgs e)
{
this.AmountLeft = (int)e.NewValue;
}
protected virtual void OnObjectiveNumChanged(ManagedPropertyChangedEventArgs e)
{
this.DivideObjectiveNum();
}
protected virtual void OnNumCompletedChanged(ManagedPropertyChangedEventArgs e)
{
this.RaiseRoutedEvent(NumCompletedChangedEvent, e);
}
protected virtual void OnAllTimeByAutoCollectChanged(ManagedPropertyChangedEventArgs e)
{
AutoCollectHelper.AutoCollectAsChanged(this, e, true, TestUser.TasksTimeByAutoCollectProperty);
}
protected virtual void OnTimeIdChanged(ManagedPropertyChangedEventArgs e)
{
var time = new DateTime((long)e.NewValue);
this.TimeString = time.ToString("yyyy/MM/dd hh:mm:ss:ms");
}
protected virtual void OnValueChanged(ManagedPropertyChangedEventArgs e)
{
this.AccurateValue = ((DateTime)e.NewValue).Ticks;
}
protected virtual void OnAmountChanged(ManagedPropertyChangedEventArgs e)
{
}
protected override void OnIdChanged(ManagedPropertyChangedEventArgs e)
{
base.OnIdChanged(e);
IdChanged = true;
}
protected virtual void OnMonthScoreChanged(ManagedPropertyChangedEventArgs e)
{
this.RaiseRoutedEvent(MonthScoreChangedEvent, e);
}
private static void OnNotEmptyCodeChanged(ManagedPropertyObject sender, ManagedPropertyChangedEventArgs e)
{
//var entity = sender as TestUser;
}
protected override void OnAmountChanged(ManagedPropertyChangedEventArgs e)
{
base.OnAmountChanged(e);
this.RaiseRoutedEvent(PriceChangedEvent, e);
}
