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);
}
internal ObjectContextForMock(EntityConnection connection, IEntityAdapter entityAdapter = null)
: base(null, null, null, entityAdapter)
{
_connection = connection;
}
protected abstract void OnConnectionChanging(IEntityAdapter connection);
