/// <summary>
/// Initializes a new instance of the <see cref="DefaultChangeTrackingDictionary"/> class.
/// </summary>
/// <param name="parent">The parent object, if any.</param>
/// <param name="parentKey">The parent key, if any.</param>
/// <param name="initialData">The initial dictionary state.</param>
/// <param name="keyComparer">The key comparer to use.</param>
public DefaultChangeTrackingDictionary(
IChangeTrackable parent,
string parentKey,
IDictionary <string, object> initialData = null,
IEqualityComparer <string> keyComparer = null)
{
if (parent != null)
{
if (string.IsNullOrEmpty(parentKey))
{
throw new ArgumentNullException(nameof(parent), $"Both {nameof(parent)} and {nameof(parentKey)} must be specified.");
}
_parent = parent;
_parentKey = parentKey;
}
_keyComparer = keyComparer ?? EqualityComparer <string> .Default;
_initialData = initialData == null
? new Dictionary <string, object>(_keyComparer)
: DeepCopy(initialData);
Reset();
}
private void InternalAcceptChanges(IChangeTrackable changeTrackable)
{
if (changeTrackable == null)
{
return;
}
var type = changeTrackable.GetType();
foreach (var propertyManagerInfo in _propertyManager.GetInfos(type))
{
AcceptChangeableValue(propertyManagerInfo, changeTrackable);
}
var hashCode = changeTrackable.GetHashCode();
if (IsNew(changeTrackable))
{
_repository.Add(changeTrackable);
_newChangeables.Remove(hashCode);
}
else if (IsChanged(changeTrackable))
{
_repository.Update(changeTrackable);
_changedChangeables.Remove(hashCode);
}
}
private void AcceptChangeableValue(IPropertyManagerInfo propertyManagerInfo, IChangeTrackable changeTrackable)
{
switch (propertyManagerInfo.InfoType)
{
case PropertyManagerInfoType.Reference: InternalAcceptChanges(propertyManagerInfo.GetReferenceValue <IChangeTrackable>(changeTrackable)); break;
//TODOcase ChangeablePropertyInfoType.Association: ChangeableListUoW.InternalAcceptChanges(changeablePropertyInfo.GetAssociationValue(changeTrackable)); break;
}
}
private ChangedRelationShip <TKey> BuildChangeRelationshipTemplate(IChangeTrackable <TKey> parent, PropertyInfo propertyInfo)
{
OwnershipActions ownershipActions = null;
var key = new Tuple <Type, PropertyInfo>(parent.GetType(), propertyInfo);
_ownerMappings.TryGetValue(key, out ownershipActions);
return(new ChangedRelationShip <TKey>(parent, propertyInfo, ownershipActions));
}
public ChangedRelationShip <TKey> CloneFor(IChangeTrackable <TKey> value, ChangeType changeType)
{
return(new ChangedRelationShip <TKey>(Parent, Property, OwnershipActions)
{
ChangeType = changeType,
Value = value
});
}
private void CloseTransaction()
{
_rootTrackable = null;
_changeables.Clear();
_newChangeables.Clear();
_deletedChangeables.Clear();
_changedChangeables.Clear();
}
public IContent CreateContentVersion(ContentReference contentLink, DateTime versionDate, string data1, string data2, string data3)
{
ContextCache.Current["CurrentITransferContext"] = (object)this;
ContextCache.Current["PageSaveDB:PageSaved"] = (object)true;
var content = _contentRepository.Get <IContent>(contentLink);
var saveAction = SaveAction.Publish | SaveAction.SkipValidation;
var command = saveAction & SaveAction.ActionMask;
SaveAction action = (content is IVersionable ? command : SaveAction.Default) | (SaveAction.ForceCurrentVersion | saveAction & SaveAction.SkipValidation);
AccessLevel requiredDestinationAccess = AccessLevel.NoAccess;
var contentData = content as ContentData;
contentData = (ContentData)contentData.CreateWritableClone();
IChangeTrackable changeTrackable = contentData as IChangeTrackable;
changeTrackable.Saved = versionDate;
changeTrackable.Changed = versionDate;
changeTrackable.Created = versionDate;
changeTrackable.SetChangedOnPublish = true;
IContent contentClone = (IContent)contentData;
contentClone.ContentLink = contentLink.ToReferenceWithoutVersion();
contentClone.ContentGuid = Guid.Empty;
if (contentClone is EditorialBlock)
{
contentClone.Property["MainBody"].Value = new XhtmlString(data1);
}
else if (contentClone is StandardPage)
{
contentClone.Property["PageName"].Value = data1;
contentClone.Property["MetaDescription"].Value = data2;
var contentArea = new ContentArea();
var contentLinks = data3.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
foreach (var link in contentLinks)
{
contentArea.Items.Add(new ContentAreaItem
{
ContentLink = new ContentReference(link)
});
}
contentClone.Property["MainContentArea"].Value = contentArea;
}
(contentClone as IVersionable).StartPublish = versionDate;
SaveAction saveAction2 = (SaveAction.SkipValidation | SaveAction.Publish) & SaveAction.ActionMask;
var contentReference = _contentRepository.Save(contentClone, saveAction2, requiredDestinationAccess);
return(content);
}
private void CheckDetached(IChangeTrackable changeTrackable)
{
if (changeTrackable == null)
{
throw new ArgumentNullException("changeTrackable");
}
if (_changeables.Contains(changeTrackable.GetHashCode()))
{
throw new ArgumentException("Instance already attached!");
}
}
public void Change_Property_Should_Raise_PropertyChanged_On_ChangedProperties()
{
var order = Helper.GetOrder();
var trackable = order.AsTrackable();
var monitor = ((INotifyPropertyChanged)trackable).Monitor();
trackable.CustomerNumber = "Test1";
IChangeTrackable <Order> changeTrackable = trackable.CastToIChangeTrackable();
monitor.Should().RaisePropertyChangeFor(ct => ct.CastToIChangeTrackable().ChangedProperties);
}
/// <summary>
/// 添加
/// </summary>
/// <typeparam name="TObject">领域对象类型</typeparam>
/// <param name="leftObj">左对象</param>
/// <param name="rightObj">右对象</param>
public void Add <TObject>(IChangeTrackable <TObject> leftObj, TObject rightObj) where TObject : IDomainObject
{
if (Equals(leftObj, null))
{
return;
}
if (Equals(rightObj, null))
{
return;
}
_changedValueCollection.AddRange(leftObj.GetChanges(rightObj));
}
public void Change_Property_Should_Raise_PropertyChanged_On_ChangeTrackingStatus_Event()
{
var order = Helper.GetOrder();
var trackable = order.AsTrackable();
((INotifyPropertyChanged)trackable).MonitorEvents();
trackable.CustomerNumber = "Test1";
IChangeTrackable <Order> changeTrackable = trackable.CastToIChangeTrackable();
changeTrackable.ShouldRaisePropertyChangeFor(ct => ct.ChangeTrackingStatus);
}
public void Init(IChangeTrackable<IIdentificationModel> model) {
this.CreateBinding(NameProperty, model.current, x => x.name);
this.CreateBinding(LocationProperty, model.current, x => x.location);
this.CreateBinding(DeviceIconUriProperty, model.current, x => x.iconUri);
this.CreateBinding(FirmwareProperty, model.current, x => x.firmware);
//this.CreateBinding(AddressProperty, model.current, x => x.ip);//return session.deviceUri.Host;
if (session != null && session.deviceUri != null)
Address = session.deviceUri.Host;
else {
Address = model.current.ip;
}
this.CreateBinding(ManufacturerProperty, model.current, x => x.manufacturer);
this.CreateBinding(DeviceModelProperty, model.current, x => x.model);
}
private ChangeState ChangeableState(IChangeTrackable changeTrackable)
{
if (!IsAttached(changeTrackable))
{
return(ChangeState.Unattached);
}
if (IsDeleted(changeTrackable))
{
return(ChangeState.Deleted);
}
if (IsNew(changeTrackable))
{
return(ChangeState.New);
}
return(IsChanged(changeTrackable) ? ChangeState.Changed : ChangeState.Unchanged);
}
private void InternalRollback(IChangeTrackable changeTrackable)
{
if (ChangeableState(changeTrackable) != ChangeState.Changed)
{
return;
}
var type = changeTrackable.GetType();
foreach (var keyValuePair in _changedChangeables[changeTrackable.GetHashCode()].AllChanges)
{
_propertyManager.GetInfo(type, keyValuePair.Key).SetValue(changeTrackable, RollbackValidObject(keyValuePair.Value.OldValue));
}
InternalAcceptChanges(changeTrackable);
}
public override void OnInvocation(MethodInvocationEventArgs e)
{
if (e.Delegate.Method.ReturnParameter.ParameterType == typeof(void))
{
// we're in the setter
IChangeTrackable target = e.Delegate.Target as IChangeTrackable;
// Implement some logic to retrieve the current value of
// the property
if (currentValue != e.GetArgumentArray()[0])
{
target.Status = Status.Dirty;
}
base.OnInvocation(e);
}
}
/// <summary>
/// Attaches the specified changeTrackable.
/// </summary>
/// <param name="changeTrackable">The changeTrackable.</param>
private void InternalAttach(IChangeTrackable changeTrackable)
{
if ((changeTrackable == null) || IsAttached(changeTrackable))
{
return;
}
foreach (var changeablePropertyInfo in _propertyManager.GetInfos(changeTrackable))
{
AttachChangeableValue(changeablePropertyInfo, changeTrackable);
}
changeTrackable.PropertyChanged += ChangeablePropertyChanged;
_changeables.Add(changeTrackable.GetHashCode());
_newChangeables.Add(changeTrackable.GetHashCode());
}
public void Init(IChangeTrackable <IIdentificationModel> model)
{
this.CreateBinding(NameProperty, model.current, x => x.name);
this.CreateBinding(LocationProperty, model.current, x => x.location);
this.CreateBinding(DeviceIconUriProperty, model.current, x => x.iconUri);
this.CreateBinding(FirmwareProperty, model.current, x => x.firmware);
//this.CreateBinding(AddressProperty, model.current, x => x.ip);//return session.deviceUri.Host;
if (session != null && session.deviceUri != null)
{
Address = session.deviceUri.Host;
}
else
{
Address = model.current.ip;
}
this.CreateBinding(ManufacturerProperty, model.current, x => x.manufacturer);
this.CreateBinding(DeviceModelProperty, model.current, x => x.model);
}
/// <summary>
/// Builds result search information for IContent
/// </summary>
/// <param name="searchHit"></param>
/// <returns></returns>
protected virtual SearchResult CreateSearchResult(IHit <IContent> searchHit)
{
Validator.ThrowIfNull(nameof(searchHit), searchHit);
// load the content from the given link
var referenceString = (searchHit.Fields["contentLink"] as JArray)?.FirstOrDefault();
ContentReference reference = null;
if (referenceString != null)
{
ContentReference.TryParse(referenceString.ToString(), out reference);
}
if (ContentReference.IsNullOrEmpty(reference))
{
throw new Exception("Unable to convert search hit to IContent!");
}
var content = _ContentRepository.Get <IContent>(reference);
ILocalizable localizable = content as ILocalizable;
IChangeTrackable changeTracking = content as IChangeTrackable;
bool onCurrentHost;
SearchResult result = new SearchResult
(
GetEditUrl(content, out onCurrentHost),
HttpUtility.HtmlEncode(content.Name),
CreatePreviewText(content)
);
result.IconCssClass = IconCssClass(content);
result.Metadata["Id"] = content.ContentLink.ToString();
result.Metadata["LanguageBranch"] = localizable == null || localizable.Language == null ? string.Empty : localizable.Language.Name;
result.Metadata["ParentId"] = content.ParentLink.ToString();
result.Metadata["IsOnCurrentHost"] = onCurrentHost ? "true" : "false";
result.Metadata["TypeIdentifier"] = SearchProviderExtensions.GetTypeIdentifier(content, _UIDescriptorRegistry);
ContentType contentType = _ContentTypeRepository.Load(content.ContentTypeID);
CreateToolTip(content, changeTracking, result, contentType);
result.Language = localizable == null || localizable.Language == null ? string.Empty : localizable.Language.NativeName;
return(result);
}
public void StartTransaction(object rootItem)
{
if (rootItem == null)
{
throw new ArgumentNullException("rootItem");
}
if (!(rootItem is IChangeTrackable))
{
throw new InvalidOperationException("rootItem is not an " + typeof(IChangeTrackable).Name);
}
if (_rootTrackable != null)
{
throw new InvalidOperationException("Transaction already running");
}
_rootTrackable = (IChangeTrackable)rootItem;
CheckDetached(_rootTrackable);
InternalAttach(_rootTrackable);
}
public void Intercept(IInvocation invocation)
{
Match match = _setterRegex.Match(invocation.Method.Name);
// we only want to intercept set calls
if (!match.Success)
{
invocation.Proceed();
return;
}
IChangeTrackable obj = (IChangeTrackable)invocation.InvocationTarget;
string property = match.Groups["property"].Value;
MethodInfo getterMethod = invocation.TargetType.GetMethod($"get_{property}");
// get the old and new values
object oldValue = getterMethod != null?getterMethod.Invoke(invocation.InvocationTarget, null) : "?";
object newValue = invocation.Arguments[0];
// check to see if something changed
if (!AreEqual(oldValue, newValue))
{
if (obj.ChangedValues == null)
{
obj.ChangedValues = new List <ChangedValue>();
}
obj.ChangedValues.Add(
new ChangedValue
{
PropertyName = property,
OldValue = oldValue,
NewValue = newValue,
ChangedAt = DateTime.Now
});
}
invocation.Proceed();
}
private void CreateToolTip(IContent content, IChangeTrackable changeTracking, SearchResult result, ContentType contentType)
{
if (string.IsNullOrEmpty(ToolTipResourceKeyBase))
{
return;
}
result.ToolTipElements.Add(new ToolTipElement(LocalizationService.GetString(string.Format(CultureInfo.InvariantCulture, "{0}/id", new object[]
{
ToolTipResourceKeyBase
})), content.ContentLink.ToString()));
if (changeTracking != null)
{
result.ToolTipElements.Add(new ToolTipElement(LocalizationService.GetString(string.Format(CultureInfo.InvariantCulture, "{0}/changed", new object[]
{
ToolTipResourceKeyBase
})), changeTracking.Changed.ToString(CultureInfo.CurrentUICulture)));
result.ToolTipElements.Add(new ToolTipElement(LocalizationService.GetString(string.Format(CultureInfo.InvariantCulture, "{0}/created", new object[]
{
ToolTipResourceKeyBase
})), changeTracking.Created.ToString(CultureInfo.CurrentUICulture)));
}
if (string.IsNullOrEmpty(ToolTipContentTypeNameResourceKey))
{
return;
}
result.ToolTipElements.Add
(new ToolTipElement(LocalizationService.GetString(string.Format(CultureInfo.InvariantCulture, "{0}/{1}", new object[]
{
ToolTipResourceKeyBase,
ToolTipContentTypeNameResourceKey
})), contentType != null ? HttpUtility.HtmlEncode(contentType.LocalizedName) : string.Empty));
}
/// <summary>
/// 添加变更
/// </summary>
/// <param name="objectBeforeChangeTrackable">对象变更前跟踪</param>
/// <param name="objectAfterChange">变更后的对象</param>
protected void AddChange <TDomainObject>(IChangeTrackable <TDomainObject> objectBeforeChangeTrackable,
TDomainObject objectAfterChange) where TDomainObject : IDomainObject =>
_changeTrackingContext.Add(objectBeforeChangeTrackable, objectAfterChange);
private bool IsNew(IChangeTrackable changeTrackable)
{
return(_newChangeables.Contains(changeTrackable.GetHashCode()));
}
public static DateTime?SearchUpdateDate(this IChangeTrackable content)
{
ObjectExtensions.ValidateNotNullArgument((object)content, "content");
return(new DateTime?(content.Changed));
}
public ChangedRelationShip(IChangeTrackable <TKey> parent, PropertyInfo property, OwnershipActions ownershipActions)
{
Parent = parent;
Property = property;
OwnershipActions = ownershipActions ?? new OwnershipActions();
}
private bool IsDeleted(IChangeTrackable changeTrackable)
{
return(_deletedChangeables.Contains(changeTrackable.GetHashCode()));
}
private bool IsAttached(IChangeTrackable changeTrackable)
{
return(_changeables.Contains(changeTrackable.GetHashCode()));
}
protected void AddChange(IChangeTrackable <TObject> objectBeforeChangeTrackable, TObject objectAfterChange)
{
_changeTrackingContext.Add(objectBeforeChangeTrackable, objectAfterChange);
}
private bool IsChanged(IChangeTrackable changeTrackable)
{
return(_changedChangeables.ContainsKey(changeTrackable.GetHashCode()));
}
