IList <int> IOperationServiceInternal.GetOperationIds(int maxAge, bool onlyNonAcknowledged, int limitAmount)
{
List <int> operations = new List <int>();
using (OperationManagementEntities entities = EntityFrameworkHelper.CreateContext <OperationManagementEntities>(EdmxPath))
{
foreach (OperationData data in entities.Operations.OrderByDescending(o => o.TimestampIncome))
{
// If we only want non-acknowledged ones
if (onlyNonAcknowledged && data.IsAcknowledged)
{
continue;
}
// If we shall ignore the age, or obey the maximum age...
if (maxAge > 0 && (DateTime.Now - data.TimestampIncome).TotalMinutes > maxAge)
{
continue;
}
operations.Add(data.Id);
// If we need to limit operations
if (limitAmount > 0 && operations.Count >= limitAmount)
{
break;
}
}
}
return(operations);
}
private void InitAsync(object sender, ElapsedEventArgs args)
{
ISQLDatabase database;
lock (_timer)
{
database = ServiceRegistration.Get <ISQLDatabase>(false);
if (database == null)
{
return;
}
_timer.Close();
_timer.Dispose();
}
using (var transaction = database.BeginTransaction())
if (transaction.Connection.GetCloneFactory(TVDB_NAME, out _dbProviderFactory, out _cloneConnection))
{
EntityFrameworkHelper.AssureKnownFactory(_dbProviderFactory);
// Register our factory to create new cloned connections
ObjectContextManager.SetDbConnectionCreator(ClonedConnectionFactory);
}
IntegrationProviderHelper.Register(@"Plugins\SlimTv.Service", @"Plugins\SlimTv.Service\castle.config");
_tvServiceThread = new TvServiceThread(Environment.GetCommandLineArgs()[0]);
_tvServiceThread.Start();
}
/// <summary>
/// Example for traversing a model
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void TraverseButton_Click(object sender, EventArgs e)
{
const int indent = 20;
ReadOnlyMetadataCollection <NavigationProperty> metadata = EntityFrameworkHelper.GetNavigationProperties <Order, NorthContext>();
var nameParts = metadata.FirstOrDefault().DeclaringType.FullName.Split('.');
Debug.WriteLine($"namespace: {nameParts[0]}");
Debug.WriteLine($" class: {nameParts[1]}");
Debug.WriteLine("");
Debug.WriteLine("navigation model names");
var navigationPropertyNames = metadata.Select(np => np.Name).ToList();
foreach (var name in navigationPropertyNames)
{
Debug.WriteLine($"{name,indent}");
}
Debug.WriteLine("");
Debug.WriteLine("RelationshipType names");
var relationNames = metadata.Select(np => np.RelationshipType.Name).ToList();
foreach (var relationName in relationNames)
{
Debug.WriteLine($"{relationName,indent}");
}
MessageBox.Show("See output window");
}
public void ModelKeys1()
{
var keys = EntityFrameworkHelper.PrimaryKeyNames <SingleKey>();
Assert.That(keys, Has.Count.EqualTo(1));
Assert.AreEqual(keys.First(), "StudentKey");
}
public MessageSendResult Handle(Command message)
{
using (var transaction = _niisWebContext.Database.BeginTransaction())
{
try
{
var document = _messageSendService.CorrespondenceAdd(message.Argument);
if (document != null)
{
message.Result.DocumentNumber = document.DocumentNum;
message.Result.DocumentUID = document.Barcode;
message.Result.DocumentDate = document.DateCreate.DateTime;
}
var paymentDocument = _messageSendService.PaymentDocumentAdd(message.Argument, document.Id);
if (paymentDocument != null)
{
message.Result.PaymentDocumentNumber = paymentDocument.DocumentNum;
message.Result.PaymentDocumentUID = paymentDocument.Barcode;
message.Result.PaymentDocumentDate = paymentDocument.DateCreate.DateTime;
}
_niisWebContext.SaveChanges();
transaction.Commit();
}
catch (Exception ex)
{
EntityFrameworkHelper.DetachAll(_niisWebContext);
transaction.Rollback();
throw new Exception("Смотри внутренний Exception", ex);
}
}
return(message.Result);
}
public UpdateSetPropertyImpl(DbContext dbContext, object idValue)
{
TEntity entity = new TEntity();
EntityFrameworkHelper.SetPrimaryKeyPropertyValue <TEntity>(entity, idValue);
this.Init(dbContext, entity);
}
public static void RegisterDbContext(Type dbContextType, IIocManager iocManager)
{
foreach (var entityType in EntityFrameworkHelper.GetEntityTypesInDbContext(dbContextType))
{
foreach (var interfaceType in entityType.GetInterfaces())
{
if (interfaceType.IsGenericType && interfaceType.GetGenericTypeDefinition() == typeof(IEntity <>))
{
var primaryKeyType = interfaceType.GenericTypeArguments[0];
if (primaryKeyType == typeof(int))
{
var genericRepositoryType = typeof(IRepository <>).MakeGenericType(entityType);
if (!iocManager.IsRegistered(genericRepositoryType))
{
iocManager.Register(
genericRepositoryType,
typeof(EfRepositoryBase <,>).MakeGenericType(dbContextType, entityType),
DependencyLifeStyle.Transient
);
}
}
var genericRepositoryTypeWithPrimaryKey = typeof(IRepository <,>).MakeGenericType(entityType, primaryKeyType);
if (!iocManager.IsRegistered(genericRepositoryTypeWithPrimaryKey))
{
iocManager.Register(
genericRepositoryTypeWithPrimaryKey,
typeof(EfRepositoryBase <, ,>).MakeGenericType(dbContextType, entityType, primaryKeyType),
DependencyLifeStyle.Transient
);
}
}
}
}
}
public void Get_ReturnsAllOrderedByName()
{
// Arrange
var dbContextMock = new Mock <IPayrollEstimatorContext>();
var employees = new List <Employee> {
new Employee {
EmployeeId = 1, FirstName = "Able", LastName = "Gable"
},
new Employee {
EmployeeId = 2, FirstName = "Zelda", LastName = "Link"
},
new Employee {
EmployeeId = 3, FirstName = "Leroy", LastName = "Jenkins"
},
new Employee {
EmployeeId = 4, FirstName = "Zoo", LastName = "Zebra"
},
new Employee {
EmployeeId = 5, FirstName = "Alice", LastName = "Wonderland"
},
}.AsQueryable();
var dbSetMock = EntityFrameworkHelper.GetMockDbSet(employees);
dbContextMock.Setup(x => x.Employees).Returns(dbSetMock.Object);
// Act
var results = new EmployeeCrud(dbContextMock.Object).Get()
.Result;
// Assert
CollectionAssert.AreEqual(employees.Select(e => e.FirstName).OrderBy(x => x),
results.Select(x => x.FirstName));
}
void IDispositioningServiceInternal.Dispatch(int operationId, string emkResourceId)
{
lock (SyncRoot)
{
using (var entities = EntityFrameworkHelper.CreateContext <DispositioningEntities>(EdmxPath))
{
bool exists = entities.DispResources.Any(_ => _.Operation_Id == operationId && _.EmkResourceId == emkResourceId);
if (exists)
{
throw new InvalidOperationException(Properties.Resources.DispatchNotPossibleEntryAlreadyExists);
}
DispResourceData data = new DispResourceData();
data.Operation_Id = operationId;
data.EmkResourceId = emkResourceId;
data.Timestamp = DateTime.Now;
entities.DispResources.AddObject(data);
entities.SaveChanges();
}
}
DispositionEventArgs args = new DispositionEventArgs(operationId, emkResourceId, DispositionEventArgs.ActionType.Dispatch);
OnDispositionEventArgs(args);
}
public override void OnStart()
{
base.OnStart();
using (OperationManagementEntities entities = EntityFrameworkHelper.CreateContext <OperationManagementEntities>(EdmxPath))
{
}
}
public void ModelKeys2()
{
var keys = EntityFrameworkHelper.PrimaryKeyNames <DoubleKey>();
Assert.That(keys, Has.Count.EqualTo(2));
Assert.AreEqual(keys.First(), "StudentKey");
Assert.AreEqual(keys.Last(), "AdmissionNum");
}
protected override void PrepareConnection(ITransaction transaction)
{
if (transaction.Connection.GetCloneFactory(TVDB_NAME, out _dbProviderFactory, out _cloneConnection))
{
EntityFrameworkHelper.AssureKnownFactory(_dbProviderFactory);
// Register our factory to create new cloned connections
ObjectContextManager.SetDbConnectionCreator(ClonedConnectionFactory);
}
}
public void ModelKeys3()
{
var keys = EntityFrameworkHelper.PrimaryKeyNames <TripleKey>();
Assert.That(keys, Has.Count.EqualTo(3));
Assert.AreEqual(keys.First(), "StudentKey");
Assert.AreEqual(keys.Skip(1).First(), "AdmissionNum");
Assert.AreEqual(keys.Last(), "Guid");
}
private async void Form1_Shown(object sender, EventArgs e)
{
var modelName = await EntityFrameworkHelper.GeModelNames <NorthContext>();
ModelNamesListBox.DataSource = modelName;
_buttons.ForEach(button => button.Enabled = true);
_buttons = null;
}
string[] IDispositioningServiceInternal.GetDispatchedResources(int operationId)
{
lock (SyncRoot)
{
using (var entities = EntityFrameworkHelper.CreateContext <DispositioningEntities>(EdmxPath))
{
return(entities.DispResources.Where(_ => _.Operation_Id == operationId).Select(_ => _.EmkResourceId).ToArray());
}
}
}
/// <inheritdoc/>
public async Task <TModel> SingleOrDefaultAsync(object[] keyValues, CancellationToken ct)
{
var findExpression = EntityFrameworkHelper.FindExpression <TEntity>(keyValues);
var item = await this.OnBaseEntityFindQuery(ct)
.SingleOrDefaultAsync(findExpression, ct)
.ConfigureAwait(false);
return(this.OnConvert(item));
}
public void PrimaryKeyExpression_2()
{
var record = new DoubleKey {
StudentKey = 1, AdmissionNum = "123"
};
var exp = EntityFrameworkHelper.PrimaryKeyExpression <DoubleKey>();
Assert.IsTrue(exp(record, new object[] { 1, "123" }));
Assert.IsFalse(exp(record, new object[] { 2, string.Empty }));
}
public void PrimaryKeyExpression_1()
{
var record = new SingleKey {
StudentKey = 1
};
var exp = EntityFrameworkHelper.PrimaryKeyExpression <SingleKey>();
Assert.IsTrue(exp(record, new object[] { 1 }));
Assert.IsFalse(exp(record, new object[] { 2 }));
}
public void FindExpression_2()
{
var record = new DoubleKey {
StudentKey = 1, AdmissionNum = "123"
};
var exp1 = EntityFrameworkHelper.FindExpression <DoubleKey>(new object[] { 1, "123" }).Compile();
var exp2 = EntityFrameworkHelper.FindExpression <DoubleKey>(new object[] { 2, string.Empty }).Compile();
Assert.IsTrue(exp1(record));
Assert.IsFalse(exp2(record));
}
public void FindExpression_1()
{
var record = new SingleKey {
StudentKey = 1
};
var exp1 = EntityFrameworkHelper.FindExpression <SingleKey>(1).Compile();
var exp2 = EntityFrameworkHelper.FindExpression <SingleKey>(2).Compile();
Assert.IsTrue(exp1(record));
Assert.IsFalse(exp2(record));
}
private static void ImportUserSettings(XDocument doc)
{
using (MigrationSettingsEntities entities = EntityFrameworkHelper.CreateContext <MigrationSettingsEntities>("Data.SettingsEntities"))
{
foreach (XElement section in doc.Root.Elements("Section"))
{
string identifier = section.Attribute("Identifier").Value;
foreach (XElement setting in section.Elements("UserSetting"))
{
try
{
string name = setting.Attribute("Name").Value;
bool isNew = true;
UserSettingData data = entities.UserSettings.FirstOrDefault(item => item.Identifier == identifier && item.Name == name);
if (data == null)
{
data = new UserSettingData();
}
else
{
isNew = false;
Logger.Instance.LogFormat(LogType.Warning, null, Resources.OverwritingExistingItem, identifier, name);
}
data.Identifier = identifier;
data.Name = name;
data.Value = setting.Value;
XAttribute isNull = setting.Attribute("IsNull");
if (isNull != null && isNull.Value.Equals(bool.TrueString, StringComparison.OrdinalIgnoreCase))
{
data.Value = null;
}
if (isNew)
{
entities.UserSettings.AddObject(data);
}
Logger.Instance.LogFormat(LogType.Info, null, Resources.SettingWritten, data.Identifier, data.Name);
}
catch (Exception ex)
{
Logger.Instance.LogFormat(LogType.Error, null, Resources.SettingWriteError);
Logger.Instance.LogException(null, ex);
}
}
}
entities.SaveChanges();
}
}
private static void ApplySettingValue(string identifier, string name, SettingItem item)
{
using (SettingsEntities entities = EntityFrameworkHelper.CreateContext <SettingsEntities>(EdmxPath))
{
UserSettingData userData = entities.GetUserSettingData(identifier, name);
if (userData != null)
{
item.ApplyUserValue(userData.Value);
}
}
}
public void PrimaryKeyExpression_3()
{
var g = Guid.NewGuid();
var record = new TripleKey {
StudentKey = 33, AdmissionNum = "1123223", Guid = g
};
var exp = EntityFrameworkHelper.PrimaryKeyExpression <TripleKey>();
Assert.IsTrue(exp(record, new object[] { 33, "1123223", g }));
Assert.IsFalse(exp(record, new object[] { 33, "1123223", Guid.NewGuid() }));
}
Operation IOperationServiceInternal.StoreOperation(Operation operation)
{
using (OperationManagementEntities entities = EntityFrameworkHelper.CreateContext <OperationManagementEntities>(EdmxPath))
{
OperationData data = new OperationData(operation);
entities.Operations.AddObject(data);
entities.SaveChanges();
operation.Id = data.Id;
return(operation);
}
}
bool IOperationServiceInternal.ExistsOperation(string operationNumber)
{
if (string.IsNullOrWhiteSpace(operationNumber))
{
return(false);
}
using (OperationManagementEntities entities = EntityFrameworkHelper.CreateContext <OperationManagementEntities>(EdmxPath))
{
return(entities.Operations.Any(item => item.OperationNumber == operationNumber));
}
}
public void FindExpression_3()
{
var g = Guid.NewGuid();
var record = new TripleKey {
StudentKey = 33, AdmissionNum = "1123223", Guid = g
};
var exp1 = EntityFrameworkHelper.FindExpression <TripleKey>(new object[] { 33, "1123223", g }).Compile();
var exp2 = EntityFrameworkHelper.FindExpression <TripleKey>(new object[] { 33, "1123223", Guid.NewGuid() }).Compile();
Assert.IsTrue(exp1(record));
Assert.IsFalse(exp2(record));
}
public static void Setup(TestContext context)
{
var builder = new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory()).AddJsonFile("appsettings.json");
_configuration = builder.Build();
EntityFrameworkHelper.CreateSchema();
DependencyInjector.Kernel.StartEntityFramework();
var kernel = Kernel.GetKernel();
kernel.Register <DbContext>(() =>
{
var opBuilder = new DbContextOptionsBuilder <SharedKernelTestContext>();
opBuilder.UseSqlServer(_configuration.GetConnectionString("SharedKernel.Test"));
return(new SharedKernelTestContext(opBuilder.Options));
});
_helperRepository = DependencyInjector.Kernel.Get <IHelperRepository>();
using (var session = _helperRepository.OpenSession())
{
var repo = session.GetRepository <Foo>();
try
{
session.StartTransaction();
var foo1 = new Foo {
Bar = 10, DataInclusao = DateTime.Now, UsuarioInclusao = "test"
};
var foo2 = new Foo {
Bar = 20, DataInclusao = DateTime.Now, UsuarioInclusao = "test"
};
var foo3 = new Foo {
Bar = 30, DataInclusao = DateTime.Now, UsuarioInclusao = "test"
};
repo.Insert(foo1);
repo.Insert(foo2);
repo.Insert(foo3);
session.CommitTransaction();
}
catch (Exception ex)
{
session.RollBackTransaction();
Console.WriteLine(ex.Message);
}
}
}
Operation IOperationServiceInternal.GetOperationById(int operationId)
{
List <Operation> operations = new List <Operation>();
using (OperationManagementEntities entities = EntityFrameworkHelper.CreateContext <OperationManagementEntities>(EdmxPath))
{
OperationData data = entities.Operations.FirstOrDefault(d => d.Id == operationId);
if (data == null)
{
return(null);
}
return(data.ToOperation());
}
}
private void Init(DbContext dbContext, TEntity entity)
{
this._DbContext = dbContext;
this._Entity = entity;
var localEntity = this._DbContext.Set <TEntity>().Local.Where(p => EntityFrameworkHelper.EqualsPrimaryKeys(p, this._Entity)).FirstOrDefault();
if (localEntity != null)
{
this._Entity = localEntity;
}
else
{
this._DbContext.Set <TEntity>().Attach(this._Entity);
}
}
public void VerifyCompositeKey_EF_Metadata()
{
using IWindsorContainer c = new WindsorContainer();
c.AddDbContext <SampleContext>()
.UseInMemory();
var ctx = c.Resolve <SampleContext>();
var names = EntityFrameworkHelper.PrimaryKeyNames <CompositeStringKey>(ctx);
Assert.That(names.Count() == 2);
Assert.AreEqual(names.First(), "Id");
Assert.AreEqual(names.Last(), "Name");
}
