public EntityEntryViewModel( IPropertyBinder <TEntity> binder = null, IEntitySelector entitySelector = null, IEntityDlgOpener dlgOpener = null, IEntityAutocompleteSelector <TEntity> autocompleteSelector = null, IEntityAdapter <TEntity> entityAdapter = null ) { if (binder != null) { this.EntityBinder = binder; } if (entitySelector != null) { this.EntitySelector = entitySelector; } if (dlgOpener != null) { this.DlgOpener = dlgOpener; } if (autocompleteSelector != null) { this.AutocompleteSelector = autocompleteSelector; } if (entityAdapter != null) { this.EntityAdapter = entityAdapter; } }
public SuperheroQuery(IEntityAdapter <Power> powerAdapter) { Field <ListGraphType <PowerType> >( "powers", resolve: context => powerAdapter.ReadAll() ); }
private void SetDirtyHandler(IEntityAdapter conn, object msg) { if (!this.IsConnected) { return; } SetDirty setDirty = msg as SetDirty; if (this.ProxyID != setDirty.ID) { return; } if (this.IsDirty) { Log <Observer> .Logger.Fatal("SetDirty received to dirty observer"); } this.IsDirty = true; if (this.SetDirty != null) { this.ResetDirtyCallback = null; this.CurrentState = Observer.State.Synchronizing; this.syncSuccess = true; this.Conn.SendMessage(new StartSync(this.ProxyID)); this.SetDirty(this, delegate(IObserver _) { if (this.syncSuccess) { this.Conn.SendMessage(new Synchronized(this.ProxyID)); } }); } }
private void ResetDirtyHandler(IEntityAdapter conn, object msg) { if (!this.IsConnected) { return; } ResetDirty resetDirty = msg as ResetDirty; if (this.ProxyID != resetDirty.ID) { return; } if (!this.IsDirty) { Log <Observer> .Logger.Fatal("ResetDirty received to not dirty observer"); } if (this.CurrentState != Observer.State.Synchronizing) { Log <Observer> .Logger.Fatal("ResetDirty received to not dirty observer"); } this.IsDirty = false; this.CurrentState = Observer.State.Normal; if (this.ResetDirtyCallback != null) { this.ResetDirtyCallback(this); this.ResetDirtyCallback = null; } }
internal static ObjectContextForMock CreateMockObjectContext <TEntity>(IEntityAdapter entityAdapter = null) { var dbConnectionMock = new Mock <DbConnection>(); dbConnectionMock.Setup(m => m.DataSource).Returns("fakeDb"); var entityConnectionMock = new Mock <EntityConnection>(); entityConnectionMock.SetupGet(m => m.StoreConnection).Returns(dbConnectionMock.Object); var entityConnection = entityConnectionMock.Object; var objectContextMock = new Mock <ObjectContextForMock>(entityConnection, entityAdapter) { CallBase = true }; objectContextMock.Setup(m => m.Connection).Returns(entityConnection); objectContextMock.Setup(m => m.EnsureConnection()); #if !NET40 objectContextMock.Setup(m => m.EnsureConnectionAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult <object>(null)); #endif var model = new EdmModel(DataSpace.SSpace); model.ProviderInfo = new DbProviderInfo(GenericProviderFactory <DbProviderFactory> .Instance.InvariantProviderName, "2008"); model.ProviderManifest = new SqlProviderManifest("2008"); var storeItemCollectionMock = new Mock <StoreItemCollection>(model) { CallBase = true }; var metadataWorkspaceMock = new Mock <MetadataWorkspace>(); metadataWorkspaceMock.Setup(m => m.GetItemCollection(DataSpace.SSpace)).Returns(storeItemCollectionMock.Object); objectContextMock.Setup(m => m.MetadataWorkspace).Returns(metadataWorkspaceMock.Object); var objectStateManagerMock = new Mock <ObjectStateManager>(metadataWorkspaceMock.Object); objectContextMock.Setup(m => m.ObjectStateManager).Returns(objectStateManagerMock.Object); var mockObjectQuery = CreateMockObjectQuery(default(TEntity), objectContext: objectContextMock.Object); var mockObjectQueryProvider = new Mock <ObjectQueryProvider>(mockObjectQuery.Object); mockObjectQueryProvider.Setup(m => m.CreateQuery <TEntity>(It.IsAny <Expression>())) .Returns(mockObjectQuery.Object); mockObjectQueryProvider.Setup(m => m.CreateQuery(It.IsAny <Expression>(), typeof(TEntity))) .Returns(mockObjectQuery.Object); var fakeQueryable = new TEntity[0].AsQueryable(); mockObjectQuery.Setup(m => m.GetEnumeratorInternal()).Returns(fakeQueryable.GetEnumerator); mockObjectQuery.Setup(m => m.GetExpression()).Returns(() => fakeQueryable.Expression); mockObjectQuery.Setup(m => m.ObjectQueryProvider).Returns(() => mockObjectQueryProvider.Object); objectContextMock.Setup(m => m.CreateQuery <TEntity>(It.IsAny <string>(), It.IsAny <ObjectParameter[]>())).Returns( () => mockObjectQuery.Object); #if !NET40 objectContextMock.Setup(m => m.EnsureConnectionAsync(It.IsAny <CancellationToken>())) .Returns(Task.FromResult <object>(null)); #endif return(objectContextMock.Object); }
public HeroRedisAdapter(string connectionString, IEntityAdapter <Power> powerAdapter) { var redis = ConnectionMultiplexer.Connect(connectionString); Db = redis.GetDatabase(); this.PowerAdapter = powerAdapter; }
public ChannelMember(long cid, IEntityAdapter fa, long ipid, ActionSync iaction) { this.CID = cid; this.FrontendAdapter = fa; this.InitialPartitionID = ipid; this.InitialAction = iaction; this.IsInChannel = false; }
internal void StartSyncHandler(IEntityAdapter conn, object msg) { if (this.CurrentState != ObserverProxy.State.Normal) { Log <ObserverProxy> .Logger.FatalFormat("StartSync received on Proxy state {0}", this.CurrentState); } this.CurrentState = ObserverProxy.State.Synchronizing; }
public TeamRedisAdapter(string connectionString, IEntityAdapter <Hero> heroAdapter) { var redis = ConnectionMultiplexer.Connect(connectionString); Db = redis.GetDatabase(); this.HeroAdapter = heroAdapter; }
protected override IEntity MakeEntity(long id, string category) { IEntity entity = base.MakeEntity(id, category); entity.Tag = new GRCClient(this, entity); entity.Used += delegate(object sender, EventArgs <IEntityAdapter> e) { if (entity.UseCount == 0) { entity.Close(); } }; entity.Using += delegate(object sender, EventArgs <IEntityAdapter> e) { IEntityAdapter value = e.Value; if (entity.Tag == null) { return; } if (value.RemoteCategory == "FrontendServiceCore.FrontendService") { GRCClient grcclient = entity.Tag as GRCClient; if (grcclient.FrontendConn != null) { grcclient.FrontendConn.Close(); } grcclient.FrontendConn = this.Connect(entity, new Location(value.RemoteID, value.RemoteCategory)); grcclient.FrontendConn.Closed += delegate(object _, EventArgs <IEntityProxy> __) { entity.Close(); }; grcclient.FrontendConn.OperationQueueOversized += delegate(object _, EventArgs <IEntityProxy> __) { entity.Close(true); }; } }; entity.Closed += delegate(object sender, EventArgs e) { try { EntityDataContext entityDataContext = new EntityDataContext(); entityDataContext.AcquireService(new long?((sender as IEntity).ID), base.Category, new int?(-1), new int?(base.ID)); } catch (Exception ex) { Log <GRCService> .Logger.ErrorFormat("Entity_Closed [EntityID : {0}] [ServiceID : {1}] [Category : {2}] - {3} ", new object[] { (sender as IEntity).ID, base.ID, base.Category, ex }); } }; Scheduler.Schedule(base.Thread, Job.Create(new Action((entity.Tag as GRCClient).MakeRequest)), this.NextMilliseconds()); return(entity); }
private void AddFailHandler(IEntityAdapter conn, object msg) { AddFail addFail = msg as AddFail; if (!this.IsConnected && this.ProxyID == 0 && addFail.ID.Equals(this.Target)) { this.Close(); addFail.ID = new ObservableIdentifier(0L, ""); } }
internal void SynchronizedHandler(IEntityAdapter conn, object msg) { if (this.CurrentState != ObserverProxy.State.Synchronizing) { Log <ObserverProxy> .Logger.FatalFormat("Synchronized received on Proxy state {0}", this.CurrentState); } this.Dirty = false; this.CurrentState = ObserverProxy.State.Normal; this.Connection.SendMessage(new ResetDirty(this.ID)); }
private string GetFullPath(IEntityAdapter converter) { Directory.CreateDirectory(_fileLocationOptions.WorkRoot); var fileName = converter.GetFileName(); var destFileName = Path.Combine(_fileLocationOptions.WorkRoot, fileName); var sourceFileName = Path.Combine("DefaultInput", fileName); if (!File.Exists(destFileName) && File.Exists(sourceFileName)) { File.Copy(sourceFileName, destFileName); } return(Path.GetFullPath(destFileName)); }
public void Init() { _controller = new PresentationController(false); _sideController = new SidePanelViewControllerMock(); _mainController = new MainViewControllerMock(); _controller.ViewControllers.Add(_mainController); _controller.ViewControllers.Add(_sideController); ApplicationManager.Current.ObjectContainer = new ObjectContainer(); _clientAdapter = new ClientAdapter(); _clientController = new EntityController<Client>(); ApplicationManager.Current.ObjectContainer.Register<IEntityController<Client>>(_clientController); _invoiceAdapter = new InvoiceAdapter(); _invoiceController = new EntityController<Invoice>(); ApplicationManager.Current.ObjectContainer.Register<IEntityController<Invoice>>(_invoiceController); }
private void AddOkHandler(IEntityAdapter conn, object msg) { AddOk addOk = msg as AddOk; if (!this.IsConnected && this.ProxyID == 0 && addOk.ObservableID.Equals(this.Target)) { this.ProxyID = addOk.ProxyID; this.IsConnected = true; this.Conn.RegisterMessageHandler(typeof(SetDirty), new Action <EntityConnection, object>(this.SetDirtyHandler)); this.Conn.RegisterMessageHandler(typeof(ResetDirty), new Action <EntityConnection, object>(this.ResetDirtyHandler)); addOk.ProxyID = 0; addOk.ObservableID = new ObservableIdentifier(0L, ""); if (this.Connected != null) { this.Connected(this); } } }
public void Init() { _controller = new PresentationController(false); _sideController = new SidePanelViewControllerMock(); _mainController = new MainViewControllerMock(); _controller.ViewControllers.Add(_mainController); _controller.ViewControllers.Add(_sideController); ApplicationManager.Current.ObjectContainer = new ObjectContainer(); _clientAdapter = new ClientAdapter(); _clientController = new EntityController <Client>(); ApplicationManager.Current.ObjectContainer.Register <IEntityController <Client> >(_clientController); _invoiceAdapter = new InvoiceAdapter(); _invoiceController = new EntityController <Invoice>(); ApplicationManager.Current.ObjectContainer.Register <IEntityController <Invoice> >(_invoiceController); }
private void Exchange(IEntityAdapter adapter, IEntityTranslator translator) { using (IComWrapper cursor = adapter.GetCursor()) { if (cursor != null) { while ((bool)cursor.Call("Следующий")) { using (SqlCommand command = connection.CreateCommand()) { translator.Translate(cursor, command); AddParameter(command, "id_sea", SqlDbType.Int, ParameterDirection.Input, session_id); command.ExecuteNonQuery(); } } } } log.Write(string.Format("ok : {0}", adapter.ToString())); }
public SuperheroMutation(IEntityAdapter <Power> powerAdapter) { Name = "CreatePowerMutation"; Field <PowerType>( "createPower", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <PowerInputType> > { Name = "power" } ), resolve: context => { var powerName = context.GetArgument <string>("name"); var power = new Power(Guid.NewGuid(), powerName); powerAdapter.Save(power); return(power); } ); }
protected override IEntity MakeEntity(long id, string category) { IEntity entity = base.MakeEntity(id, category); entity.Tag = new CafeAuth(this, entity); entity.Using += delegate(object sender, EventArgs <IEntityAdapter> e) { IEntityAdapter value = e.Value; if (entity.Tag == null) { return; } if (value.RemoteCategory == "FrontendServiceCore.FrontendService") { CafeAuth cafeAuth = entity.Tag as CafeAuth; if (cafeAuth.FrontendConn != null) { cafeAuth.FrontendConn.Close(); } cafeAuth.FrontendConn = this.Connect(entity, new Location(value.RemoteID, value.RemoteCategory)); } }; entity.Used += delegate(object sender, EventArgs <IEntityAdapter> e) { IEntityAdapter value = e.Value; if (value.RemoteCategory == "FrontendServiceCore.FrontendService" || entity.UseCount == 0) { entity.Close(); Scheduler.Schedule(this.Thread, Job.Create(delegate { if (!entity.IsClosed) { entity.Close(true); } }), new TimeSpan(0, 0, 30)); } }; return(entity); }
internal ObjectContextForMock(EntityConnection connection, IEntityAdapter entityAdapter = null) : base(null, null, null, entityAdapter) { _connection = connection; }
public HeroSqlAdapter(string connectionString, IEntityAdapter <Power> powerAdapter) { this.ConnectionString = connectionString; this.PowerAdapter = powerAdapter; }
/// <summary> /// Accept changes to entities and relationships processed by this translator instance. /// </summary> /// <param name="adapter">Data adapter</param> /// <returns>Number of state entries affected.</returns> private int AcceptChanges(IEntityAdapter adapter) { int affectedCount = 0; foreach (IEntityStateEntry stateEntry in m_stateEntries) { // only count and accept changes for state entries that are being explicitly modified if (EntityState.Unchanged != stateEntry.State) { if (adapter.AcceptChangesDuringUpdate) { stateEntry.AcceptChanges(); } affectedCount++; } } return affectedCount; }
/// <summary> /// Persists stateManager changes to the store. /// </summary> /// <param name="stateManager">StateManager containing changes to persist.</param> /// <param name="adapter">Map adapter requesting the changes.</param> /// <returns>Total number of state entries affected</returns> internal static Int32 Update(IEntityStateManager stateManager, IEntityAdapter adapter) { // provider/connection details EntityConnection connection = (EntityConnection)adapter.Connection; MetadataWorkspace metadataWorkspace = connection.GetMetadataWorkspace(); int? commandTimeout = adapter.CommandTimeout; UpdateTranslator translator = new UpdateTranslator(stateManager, metadataWorkspace, connection, commandTimeout); // tracks values for identifiers in this session Dictionary<int, object> identifierValues = new Dictionary<int, object>(); // tracks values for generated values in this session List<KeyValuePair<PropagatorResult, object>> generatedValues = new List<KeyValuePair<PropagatorResult, object>>(); IEnumerable<UpdateCommand> orderedCommands = translator.ProduceCommands(); // used to track the source of commands being processed in case an exception is thrown UpdateCommand source = null; try { foreach (UpdateCommand command in orderedCommands) { // Remember the data sources so that we can throw meaningful exception source = command; long rowsAffected = command.Execute(translator, connection, identifierValues, generatedValues); translator.ValidateRowsAffected(rowsAffected, source); } } catch (Exception e) { // we should not be wrapping all exceptions if (UpdateTranslator.RequiresContext(e)) { throw EntityUtil.Update(System.Data.Entity.Strings.Update_GeneralExecutionException, e, translator.DetermineStateEntriesFromSource(source)); } throw; } translator.BackPropagateServerGen(generatedValues); int totalStateEntries = translator.AcceptChanges(adapter); return totalStateEntries; }
public void Enlist(IEntityAdapter adapter, IEntityTranslator translator) { exchange_list.Add(adapter, translator); }
protected override void OnConnectionChanging(IEntityAdapter connection) { base.OnConnectionChanging(connection); }
protected override IEntity MakeEntity(long id, string category) { AntiCpXSvr.SafeClientHandle safeClientHandle = new AntiCpXSvr.SafeClientHandle(this.serverHandle); if (safeClientHandle.IsInvalid) { Log <HackShieldService> .Logger.WarnFormat("Error while making Hackshield handler : {0}", id); return(null); } IEntity entity = base.MakeEntity(id, category); entity.Tag = new HackShieldClient(this, entity, safeClientHandle); entity.Using += delegate(object sender, EventArgs <IEntityAdapter> e) { IEntityAdapter value = e.Value; if (entity.Tag == null) { return; } if (value.RemoteCategory == "FrontendServiceCore.FrontendService") { HackShieldClient hackShieldClient = entity.Tag as HackShieldClient; if (hackShieldClient.FrontendConn != null) { hackShieldClient.FrontendConn.Close(); } hackShieldClient.FrontendConn = this.Connect(entity, new Location(value.RemoteID, value.RemoteCategory)); hackShieldClient.FrontendConn.Closed += delegate(object _, EventArgs <IEntityProxy> __) { entity.Close(); }; hackShieldClient.FrontendConn.OperationQueueOversized += delegate(object _, EventArgs <IEntityProxy> __) { entity.Close(true); }; } }; entity.Closed += delegate(object sender, EventArgs e) { try { EntityDataContext entityDataContext = new EntityDataContext(); entityDataContext.AcquireService(new long?((sender as IEntity).ID), base.Category, new int?(-1), new int?(base.ID)); } catch (Exception ex) { Log <HackShieldService> .Logger.ErrorFormat("Entity_Closed [EntityID : {0}] [ServiceID : {1}] [Category : {2}] - {3} ", new object[] { (sender as IEntity).ID, base.ID, base.Category, ex }); } }; entity.Used += delegate(object sender, EventArgs <IEntityAdapter> e) { if (entity.UseCount == 0) { entity.Close(); } }; if (!FeatureMatrix.IsEnable("HackShieldConnCheckOff")) { Scheduler.Schedule(base.Thread, Job.Create(new Action((entity.Tag as HackShieldClient).MakeRequest)), this.NextMilliseconds()); } if (FeatureMatrix.IsEnable("TcProtect")) { Scheduler.Schedule(base.Thread, Job.Create(new Action((entity.Tag as HackShieldClient).MakeTcProtectRequest)), 0); } return(entity); }
public TeamSqlAdapter(string connectionString, IEntityAdapter <Hero> heroAdapter) { this.ConnectionString = connectionString; this.HeroAdapter = heroAdapter; }
internal static ObjectContext CreateMockObjectContext <TEntity>(EntityConnection entityConnection = null, IEntityAdapter entityAdapter = null) { if (entityConnection == null) { var dbConnectionMock = new Mock <DbConnection>(); dbConnectionMock.Setup(m => m.DataSource).Returns("fakeDb"); dbConnectionMock.Setup(m => m.ConnectionString).Returns("Data Source=fakeDb"); dbConnectionMock.Protected().SetupGet <DbProviderFactory>("DbProviderFactory") .Returns(GenericProviderFactory <DbProviderFactory> .Instance); var entityConnectionMock = new Mock <EntityConnection>(); entityConnectionMock.SetupGet(m => m.StoreConnection).Returns(dbConnectionMock.Object); entityConnection = entityConnectionMock.Object; var state = ConnectionState.Closed; entityConnectionMock.Setup(m => m.Close()).Callback(() => { state = ConnectionState.Closed; }); entityConnectionMock.Setup(m => m.Open()).Callback( () => { state = ConnectionState.Open; }); #if !NET40 entityConnectionMock.Setup(m => m.OpenAsync(It.IsAny <CancellationToken>())).Returns( () => { state = ConnectionState.Open; return(Task.FromResult(true)); }); #endif entityConnectionMock.Setup(m => m.State).Returns(() => state); } var objectContextMock = new Mock <ObjectContext>(null, null, null, entityAdapter) { CallBase = true }; objectContextMock.Setup(m => m.Connection).Returns(entityConnection); var model = EdmModel.CreateStoreModel( new DbProviderInfo(GenericProviderFactory <DbProviderFactory> .Instance.InvariantProviderName, "2008"), new SqlProviderManifest("2008")); var storeItemCollectionMock = new Mock <StoreItemCollection>(model) { CallBase = true }; var metadataWorkspaceMock = new Mock <MetadataWorkspace>(); metadataWorkspaceMock.Setup(m => m.GetItemCollection(DataSpace.SSpace)).Returns(storeItemCollectionMock.Object); objectContextMock.Setup(m => m.MetadataWorkspace).Returns(metadataWorkspaceMock.Object); var objectStateManagerMock = new Mock <ObjectStateManager>(metadataWorkspaceMock.Object); objectContextMock.Setup(m => m.ObjectStateManager).Returns(objectStateManagerMock.Object); var mockObjectQuery = CreateMockObjectQuery(default(TEntity), objectContext: objectContextMock.Object); var mockObjectQueryProvider = new Mock <ObjectQueryProvider>(mockObjectQuery.Object); mockObjectQueryProvider.Setup(m => m.CreateQuery <TEntity>(It.IsAny <Expression>())) .Returns(mockObjectQuery.Object); mockObjectQueryProvider.Setup(m => m.CreateQuery(It.IsAny <Expression>(), typeof(TEntity))) .Returns(mockObjectQuery.Object); var fakeQueryable = new TEntity[0].AsQueryable(); mockObjectQuery.Setup(m => m.GetEnumeratorInternal()).Returns(fakeQueryable.GetEnumerator); mockObjectQuery.Setup(m => m.GetExpression()).Returns(() => fakeQueryable.Expression); mockObjectQuery.Setup(m => m.ObjectQueryProvider).Returns(() => mockObjectQueryProvider.Object); objectContextMock.Setup(m => m.CreateQuery <TEntity>(It.IsAny <string>(), It.IsAny <ObjectParameter[]>())).Returns( () => mockObjectQuery.Object); return(objectContextMock.Object); }
public virtual CommonEEVMBuilder <TEntity> UseFuncAdapter(Func <object, TEntity> getEntityByNode) { EntityAdapter = new FuncEntityAdapter <TEntity>(getEntityByNode); return(this); }
public virtual CommonEEVMBuilder <TEntity> UseAdapter(IEntityAdapter <TEntity> adapter) { EntityAdapter = adapter; return(this); }
protected abstract void OnConnectionChanging(IEntityAdapter connection);