public CreateProductTypeCommandHandler(
IRepository <ProductType> productTypeRepository,
IChangeTracker <ProductType> changeTracker)
{
_productTypeRepository = productTypeRepository;
_changeTracker = changeTracker;
}
public SQLTriggerBinding(ParameterInfo parameter, INameResolver nameResolver,
IChangeTracker changeTracker, SQLTriggerAttribute attribute)
{
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
if (nameResolver == null)
{
throw new ArgumentNullException(nameof(nameResolver));
}
if (attribute == null)
{
throw new ArgumentNullException(nameof(attribute));
}
if (changeTracker == null)
{
throw new ArgumentNullException(nameof(changeTracker));
}
this._parameter = parameter;
this._nameResolver = nameResolver;
this._attribute = attribute;
this._changeTracker = changeTracker;
}
private object AddElement <T>(IChangeTracker changeTracker, IEntityManager entityManager, T existing, object updateItem, object dbCollection)
{
if (!_isOwned)
{
updateItem = changeTracker.AttachAndReloadAssociatedEntity(updateItem);
}
else if (changeTracker.GetItemState(updateItem) == EntityState.Detached)
{
var instance = entityManager.CreateEmptyEntityWithKey(updateItem);
changeTracker.AddItem(instance);
changeTracker.UpdateItem(updateItem, instance);
foreach (var childMember in Members)
{
childMember.Update(changeTracker, entityManager, instance, updateItem);
}
updateItem = instance;
}
dbCollection.GetType().GetMethod("Add").Invoke(dbCollection, new[] { updateItem });
if (_isOwned)
{
changeTracker.AttachCyclicNavigationProperty(existing, updateItem, GetMappedNaviationProperties());
}
return(updateItem);
}
/// <summary>
/// Initializes a new instance of the <see cref="FakeTrackableProxyClass"/> class.
/// </summary>
/// <param name="typeToProxy">The type to proxy.</param>
/// <param name="proxyHydrator">The proxy hydrator.</param>
public FakeTrackableProxyClass(Type typeToProxy, IProxyHydrator proxyHydrator)
{
_typeToProxy = typeToProxy;
_isLoaded = (proxyHydrator == null);
_proxyHydrator = proxyHydrator;
_changeTracker = new ChangeTracker(GetInitialValues);
}
/// <summary>
/// Creates a instance of the NubeSync client
/// </summary>
/// <param name="dataStore">The local storage</param>
/// <param name="url">The address of the server hosting the NubeSync REST APIs</param>
/// <param name="authentication">Optional: a authentication provider, if the server requires the requests to be authenticated.</param>
/// <param name="httpClient">Optional: the HttpClient that is used for communicating with the server.</param>
/// <param name="changeTracker">Optional: the change tracker generating the operations.</param>
public NubeClient(
IDataStore dataStore,
string?url = null,
INubeAuthentication?authentication = null,
HttpClient?httpClient = null,
IChangeTracker?changeTracker = null,
string?operationsUrl = null)
{
if (string.IsNullOrEmpty(url) && httpClient == null)
{
throw new Exception("Either the server url or a HttpClient instance has to be provided.");
}
_dataStore = dataStore;
_authentication = authentication;
_httpClient = httpClient ?? new HttpClient();
_changeTracker = changeTracker ?? new ChangeTracker();
_operationsUrl = operationsUrl ?? "/operations";
_nubeTableTypes = new Dictionary <string, string>();
if (!string.IsNullOrEmpty(url))
{
_httpClient.BaseAddress = new Uri(url);
}
}
public override void Update <T>(IChangeTracker changeTracker, IEntityManager entityManager, T existing, T entity)
{
var innerElementType = GetCollectionElementType();
var updateValues = GetValue <IEnumerable>(entity) ?? new List <object>();
var dbCollection = GetValue <IEnumerable>(existing) ?? CreateMissingCollection(existing, innerElementType);
var dbHash = dbCollection.Cast <object>().ToDictionary(item => entityManager.CreateEntityKey(item));
// Iterate through the elements from the updated graph and try to match them against the db graph
var updateList = updateValues.OfType <object>().ToList();
for (int i = 0; i < updateList.Count; i++)
{
var updateItem = updateList[i];
var key = entityManager.CreateEntityKey(updateItem);
// try to find item with same key in db collection
object dbItem;
if (dbHash.TryGetValue(key, out dbItem))
{
UpdateElement(changeTracker, entityManager, existing, updateItem, dbItem);
dbHash.Remove(key);
}
else
{
updateList[i] = AddElement(changeTracker, entityManager, existing, updateItem, dbCollection);
}
}
// remove obsolete items
foreach (var dbItem in dbHash.Values)
{
RemoveElement(changeTracker, dbItem, dbCollection);
}
}
/// <summary>
/// Parses the relationship.
/// </summary>
/// <param name="relationship">The relationship.</param>
/// <param name="invalidObjects">The invalid objects.</param>
private void ParseRelationship(IChangeTracker <IMutableIdKey> relationship, ISet <long> invalidObjects)
{
/////
// Argument check.
/////
if (relationship == null)
{
return;
}
if (invalidObjects == null)
{
/////
// Reinitialize the set.
/////
invalidObjects = new HashSet <long>( );
}
if (relationship.Flushed)
{
/////
// All entities are invalid.
/////
foreach (var modification in relationship.Where(pair => pair != null))
{
invalidObjects.Add(modification.Key);
}
return;
}
/////
// Process the added relationships.
/////
if (relationship.Added != null && relationship.Added.Any( ))
{
/////
// All added entities are invalid.
/////
foreach (var modification in relationship.Added.Where(pair => pair != null))
{
invalidObjects.Add(modification.Key);
}
}
/////
// Process the removed relationships.
/////
if (relationship.Removed != null && relationship.Removed.Any( ))
{
/////
// All removed entities are invalid.
/////
foreach (var modification in relationship.Removed.Where(pair => pair != null))
{
invalidObjects.Add(modification.Key);
}
}
}
/// <summary>
/// Sets the entity relationships.
/// </summary>
/// <param name="entityId">The entity id.</param>
/// <param name="relationshipId">The relationship id.</param>
/// <param name="direction">The direction.</param>
/// <param name="value">The value.</param>
internal void SetEntityRelationships(long entityId, long relationshipId, Direction direction, IChangeTracker <IMutableIdKey> value)
{
if (IsValid)
{
string key = string.Format("{0}.{1}.{2}", entityId, relationshipId, direction);
_entityRelationshipCache[key] = value;
}
}
public Repository()
{
Items = new Dictionary <Guid, BaseModel>();
_proxyClassBuilder = new ProxyClassBuilder(this);
ChangeTracker = new RepositoryChangeTracker {
Repository = this
};
}
internal AppLibraryStore(Settings settings, XmlStore inner, IChangeTracker changeTracker)
{
Ensure.NotNull(settings, "settings");
Ensure.NotNull(inner, "inner");
Ensure.NotNull(changeTracker, "changeTracker");
this.settings = settings;
this.inner = inner;
this.changeTracker = changeTracker;
}
public DeleteMovieCommand(MovieCollection collection, INavigator navigator, IChangeTracker changeTracker)
{
Ensure.NotNull(collection, "collection");
Ensure.NotNull(navigator, "navigator");
Ensure.NotNull(changeTracker, "changeTracker");
this.collection = collection;
this.navigator = navigator;
this.changeTracker = changeTracker;
}
public AppNavigator(App application, ILibraryStore store, IChangeTracker changeTracker)
{
Ensure.NotNull(application, "application");
Ensure.NotNull(store, "store");
Ensure.NotNull(changeTracker, "changeTracker");
this.application = application;
this.store = store;
this.changeTracker = changeTracker;
}
/// <summary>
/// Adds an element with the provided key and value to the <see cref="T:System.Collections.Generic.IDictionary`2" />.
/// </summary>
/// <param name="key">The object to use as the key of the element to add.</param>
/// <param name="value">The object to use as the value of the element to add.</param>
public void Add(long key, IChangeTracker <IMutableIdKey> value)
{
if (!IsAttached)
{
Attach( );
}
Value.Add(key, value);
}
/// <inheritdoc />
public MyOrm(
IDatabaseDriver driver,
ISqlStatementBuilder sqlBuilder,
IChangeTracker changeTracker)
{
_dbDriver = driver;
_sqlBuilder = sqlBuilder;
ChangeTracker = changeTracker;
}
private object CreateNewPersistedEntity <T>(IChangeTracker changeTracker, T existing, object newValue) where T : class
{
var instance = Activator.CreateInstance(newValue.GetType(), true);
SetValue(existing, instance);
changeTracker.AddItem(instance);
changeTracker.UpdateItem(newValue, instance);
return(instance);
}
// overridden by different implementations
public virtual void Update <T>(IChangeTracker changeTracker, IEntityManager entityManager, T persisted, T updating) where T : class
{
changeTracker.UpdateItem(updating, persisted, true);
// Foreach branch perform recursive update
foreach (var member in Members)
{
member.Update(changeTracker, entityManager, persisted, updating);
}
}
private void RemoveElement(IChangeTracker changeTracker, object dbItem, object dbCollection)
{
dbCollection.GetType().GetMethod("Remove").Invoke(dbCollection, new[] { dbItem });
changeTracker.AttachRequiredNavigationProperties(dbItem, dbItem);
if (_isOwned)
{
changeTracker.RemoveItem(dbItem);
}
}
public TodoItemsController(
IAuthentication authentication,
IOperationService operationService,
IChangeTracker changeTracker,
DataContext context)
{
_authentication = authentication;
_operationService = operationService;
_changeTracker = changeTracker;
_context = context;
}
public ImpactController(
ILoggerFactory loggerFactory,
TelemetryClient telemetry,
IHttpContextAccessor contextAccessor,
IChangeTracker changeTracker)
{
_logger = loggerFactory.CreateLogger <ImpactController>();
_telemetry = telemetry;
_contextAccessor = contextAccessor;
_changeTracker = changeTracker;
}
public ChangeModelTester(bool startTrackingOnInit)
{
changeTracker = new ChangeTracker(LoadInitialValues);
if (!startTrackingOnInit)
{
return;
}
changeTracker.Init();
changeTracker.Start();
Version = changeTracker.Version;
}
/// <summary>
/// Initializes a new instance of the <see cref="PersistenceAction"/> class.
/// </summary>
/// <param name="mongoSession">The mongo session.</param>
/// <param name="mongoSessionCache">The mongo session cache.</param>
/// <param name="changeTracker">The change tracker.</param>
public PersistenceAction(IMongoSessionImplementor mongoSession, IMongoSessionCache mongoSessionCache, IChangeTracker changeTracker)
{
if (mongoSession == null)
throw new ArgumentNullException("mongoSession");
if (mongoSessionCache == null)
throw new ArgumentNullException("mongoSessionCache");
if (changeTracker == null)
throw new ArgumentNullException("changeTracker");
this.ChangeTracker = changeTracker;
this.MongoSessionCache = mongoSessionCache;
this.MongoSession = mongoSession;
}
public RecipeRepository(
ISessionHolder sessionHolder,
IMongoDatabase mongoDatabase,
IChangeTracker changeTracker)
{
this.sessionHolder = sessionHolder ?? throw new ArgumentNullException(nameof(sessionHolder));
this.changeTracker = changeTracker ?? throw new ArgumentNullException(nameof(changeTracker));
if (mongoDatabase == null)
{
throw new ArgumentNullException(nameof(mongoDatabase));
}
this.recipesCollection = mongoDatabase.GetCollection <Recipe>(RecipesCollectionName);
}
private void UpdateElement <T>(IChangeTracker changeTracker, IEntityManager entityManager, T existing, object updateItem, object dbItem)
{
if (!_isOwned)
{
return;
}
changeTracker.UpdateItem(updateItem, dbItem);
changeTracker.AttachCyclicNavigationProperty(existing, updateItem, GetMappedNaviationProperties());
foreach (var childMember in Members)
{
childMember.Update(changeTracker, entityManager, dbItem, updateItem);
}
}
public MovieEditWindow(INavigator navigator, IChangeTracker changeTracker, Library library, Movie model)
: base(navigator, library)
{
Ensure.NotNull(changeTracker, "changeTracker");
Ensure.NotNull(library, "library");
InitializeComponent();
kebClose.Command = new DelegateCommand(Close);
this.changeTracker = changeTracker;
this.library = library;
this.modelDefinition = library.MovieDefinition;
this.model = model;
}
private void Init()
{
_container.Configure(_ =>
{
_.Scan(s =>
{
s.TheCallingAssembly();
s.WithDefaultConventions();
});
_.For <IChangeTracker>().Singleton();
});
_tracker = _container.GetInstance <IChangeTracker>();
}
/// <summary>
/// Creates a instance of the NubeSync client
/// </summary>
/// <param name="dataStore">The local storage</param>
/// <param name="url">The address of the server hosting the NubeSync REST APIs</param>
/// <param name="authentication">Optional: a authentication provider, if the server requires the requests to be authenticated.</param>
/// <param name="httpClient">Optional: the HttpClient that is used for communicating with the server.</param>
/// <param name="changeTracker">Optional: the change tracker generating the operations.</param>
public NubeClient(
IDataStore dataStore,
string url,
INubeAuthentication?authentication = null,
HttpClient?httpClient = null,
IChangeTracker?changeTracker = null)
{
_dataStore = dataStore;
_authentication = authentication;
_httpClient = httpClient ?? new HttpClient();
_changeTracker = changeTracker ?? new ChangeTracker();
_nubeTableTypes = new Dictionary <string, string>();
_httpClient.BaseAddress = new Uri(url);
}
/// <summary>
/// Aggregates the types.
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="field">The field.</param>
/// <param name="direction">The direction.</param>
/// <param name="accumulator">The accumulator.</param>
private static void AggregateTypes(IEntity entity, IEntityRef field, Direction direction, HashSet <long> accumulator)
{
/////
// Get the entities specified field.
/////
IChangeTracker <IMutableIdKey> results = Entity.GetRelationships(entity, field, direction);
if (results != null)
{
foreach (var result in results)
{
/////
// Stop infinite recursion.
/////
if (!accumulator.Contains(result.Key))
{
/////
// Add the entity id to the accumulator.
/////
accumulator.Add(result.Key);
IEntity destination;
var localCache = Entity.GetLocalCache();
if (!localCache.TryGetValue(result.Key, out destination))
{
EntityCache.Instance.TryGetValue(result.Key, out destination);
}
if (destination == null)
{
destination = Entity.Get(result.Key);
}
if (destination != null)
{
/////
// Aggregate the results from the result.
/////
AggregateTypes(destination, field, direction, accumulator);
}
}
}
}
}
public LibraryConfigurationWindow(INavigator navigator, IChangeTracker changeTracker, Library library)
: base(navigator, library)
{
Ensure.NotNull(changeTracker, "changeTracker");
Ensure.NotNull(library, "library");
UserModelPresenter.SetContainer(this, new ModelDefinitionContainer());
UserModelPresenter.SetValueProviderCollection(this, new FieldValueProviderCollection());
InitializeComponent();
kebClose.Command = new DelegateCommand(Close);
this.changeTracker = changeTracker;
this.library = library;
this.modelDefinition = library.ConfigurationDefinition;
}
public SQLTriggerListener(ITriggeredFunctionExecutor executor,
IChangeTracker changeTracker, SQLTriggerAttribute attribute)
{
if (executor == null)
{
throw new ArgumentNullException(nameof(executor));
}
if (attribute == null)
{
throw new ArgumentNullException(nameof(attribute));
}
if (changeTracker == null)
{
throw new ArgumentNullException(nameof(changeTracker));
}
this._executor = executor;
this._changeTracker = changeTracker;
this._attribute = attribute;
}
public override void Update <T>(IChangeTracker changeTracker, IEntityManager entityManager, T persisted, T updating)
{
var dbValue = GetValue <object>(persisted);
var newValue = GetValue <object>(updating);
if (newValue == null)
{
SetValue(persisted, null);
return;
}
// do nothing if the key is already identical
if (entityManager.AreKeysIdentical(newValue, dbValue))
{
return;
}
newValue = changeTracker.AttachAndReloadAssociatedEntity(newValue);
SetValue(persisted, newValue);
}
public SQLTriggerConfigProvider(INameResolver nameResolver,
ILoggerFactory loggerFactory, IChangeTracker changeTracker)
{
if (nameResolver == null)
{
throw new ArgumentNullException(nameof(nameResolver));
}
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
if (changeTracker == null)
{
throw new ArgumentNullException(nameof(changeTracker));
}
this._nameResolver = nameResolver;
this._loggerFactory = loggerFactory;
this._changeTracker = changeTracker;
}
public static Mock<IVim> CreateVim(
IRegisterMap registerMap = null,
MarkMap map = null,
IVimGlobalSettings settings = null,
IVimHost host = null,
IKeyMap keyMap = null,
IChangeTracker changeTracker = null,
IKeyboardDevice keyboardDevice = null,
IMouseDevice mouseDevice = null)
{
registerMap = registerMap ?? CreateRegisterMap().Object;
map = map ?? new MarkMap(new TrackingLineColumnService());
settings = settings ?? new GlobalSettings();
host = host ?? new MockVimHost();
keyMap = keyMap ?? (new KeyMap());
keyboardDevice = keyboardDevice ?? (new Mock<IKeyboardDevice>(MockBehavior.Loose)).Object;
mouseDevice = mouseDevice ?? (new Mock<IMouseDevice>(MockBehavior.Loose)).Object;
changeTracker = changeTracker ?? new ChangeTracker(new TextChangeTrackerFactory(keyboardDevice, mouseDevice));
var mock = new Mock<IVim>(MockBehavior.Strict);
mock.Setup(x => x.RegisterMap).Returns(registerMap);
mock.Setup(x => x.MarkMap).Returns(map);
mock.Setup(x => x.Settings).Returns(settings);
mock.Setup(x => x.VimHost).Returns(host);
mock.Setup(x => x.KeyMap).Returns(keyMap);
mock.Setup(x => x.ChangeTracker).Returns(changeTracker);
return mock;
}
/// <summary>
/// Initializes a new instance of the <see cref="FindOneAction"/> class.
/// </summary>
/// <param name="mongoSession">The mongoSession.</param>
/// <param name="mongoSessionCache">The mongo session cache.</param>
/// <param name="changeTracker">The change tracker.</param>
public FindOneAction(IMongoSessionImplementor mongoSession, IMongoSessionCache mongoSessionCache, IChangeTracker changeTracker)
: base(mongoSession, mongoSessionCache, changeTracker)
{
}
private void CreateForText(params string[] lines)
{
_textBuffer = Utils.EditorUtil.CreateBuffer(lines);
_textView = Utils.MockObjectFactory.CreateTextView(_textBuffer);
_textView.SetupGet(x => x.HasAggregateFocus).Returns(true);
_buffer = new MockVimBuffer();
_buffer.TextViewImpl = _textView.Object;
_buffer.TextBufferImpl = _textBuffer;
_normalMode = new MockNormalMode();
_buffer.ModeImpl = _normalMode;
_trackerRaw = new ChangeTracker();
_tracker = _trackerRaw;
_trackerRaw.OnVimBufferCreated(_buffer);
}
internal static Mock<IVim> CreateVim(
IRegisterMap registerMap = null,
MarkMap map = null,
IVimGlobalSettings settings = null,
IVimHost host = null,
IKeyMap keyMap = null,
IChangeTracker changeTracker = null)
{
registerMap = registerMap ?? CreateRegisterMap().Object;
map = map ?? new MarkMap(new TrackingLineColumnService());
settings = settings ?? new GlobalSettings();
host = host ?? new FakeVimHost();
keyMap = keyMap ?? (new KeyMap());
changeTracker = changeTracker ?? new ChangeTracker();
var mock = new Mock<IVim>(MockBehavior.Strict);
mock.Setup(x => x.RegisterMap).Returns(registerMap);
mock.Setup(x => x.MarkMap).Returns(map);
mock.Setup(x => x.Settings).Returns(settings);
mock.Setup(x => x.VimHost).Returns(host);
mock.Setup(x => x.KeyMap).Returns(keyMap);
mock.Setup(x => x.ChangeTracker).Returns(changeTracker);
return mock;
}
private void CreateForText(params string[] lines)
{
_textBuffer = Utils.EditorUtil.CreateBuffer(lines);
_textView = Mock.MockObjectFactory.CreateTextView(_textBuffer);
_textView.SetupGet(x => x.HasAggregateFocus).Returns(true);
_buffer = new MockVimBuffer();
_buffer.TextViewImpl = _textView.Object;
_buffer.TextBufferImpl = _textBuffer;
var factory = new MockFactory(MockBehavior.Loose);
factory.DefaultValue = DefaultValue.Mock;
_buffer.NormalModeImpl = factory.Create<INormalMode>().Object;
_buffer.VisualBlockModeImpl = factory.Create<IVisualMode>().Object;
_buffer.VisualCharacterModeImpl = factory.Create<IVisualMode>().Object;
_buffer.VisualLineModeImpl = factory.Create<IVisualMode>().Object;
_trackerRaw = new ChangeTracker();
_tracker = _trackerRaw;
_trackerRaw.OnVimBufferCreated(_buffer);
}
private void CreateForText(params string[] lines)
{
_textBuffer = EditorUtil.CreateBuffer(lines);
_textView = MockObjectFactory.CreateTextView(_textBuffer);
_textView.SetupGet(x => x.HasAggregateFocus).Returns(true);
_normalModeRunner = new MockCommandRunner();
_normalMode = new MockNormalMode() { CommandRunnerImpl = _normalModeRunner };
_buffer = new MockVimBuffer() { TextViewImpl = _textView.Object, TextBufferImpl = _textBuffer, NormalModeImpl = _normalMode };
_textChangeTracker = new MockTextChangeTracker() { VimBufferImpl = _buffer };
_factory = new MockRepository(MockBehavior.Loose);
_factory.DefaultValue = DefaultValue.Mock;
_textChangeTrackerFactory = _factory.Create<ITextChangeTrackerFactory>();
_textChangeTrackerFactory.Setup(x => x.GetTextChangeTracker(_buffer)).Returns(_textChangeTracker);
_buffer.VisualBlockModeImpl = _factory.Create<IVisualMode>().Object;
_buffer.VisualCharacterModeImpl = _factory.Create<IVisualMode>().Object;
_buffer.VisualLineModeImpl = _factory.Create<IVisualMode>().Object;
_trackerRaw = new ChangeTracker(_textChangeTrackerFactory.Object);
_tracker = _trackerRaw;
_trackerRaw.OnVimBufferCreated(_buffer);
}
