private static ReadCommandResult ExecuteCommand(ReadCommandInfo commandInfo, UnitOfWorkScope scope)
{
var commands = scope.Resolve <IIndex <Type, IEnumerable <ICommandImplementation> > >();
var readCommand = (ReadCommand)commands[typeof(ReadCommandInfo)].Single();
return((ReadCommandResult)readCommand.Execute(commandInfo).Data.Value);
}
private static void InitializeData(UnitOfWorkScope scope)
{
scope.Resolve <ISqlExecuter>().ExecuteSql(new[]
{
"DELETE FROM TestQueryDataStructureCommand.E;",
"INSERT INTO TestQueryDataStructureCommand.E(Name) SELECT 'a';",
"INSERT INTO TestQueryDataStructureCommand.E(Name) SELECT 'b';",
"INSERT INTO TestQueryDataStructureCommand.E(Name) SELECT 'c';",
"INSERT INTO TestQueryDataStructureCommand.E(Name) SELECT 'd';",
"INSERT INTO TestQueryDataStructureCommand.E(Name) SELECT 'e';"
});
}
private static void InitializeData(UnitOfWorkScope scope)
{
scope.Resolve <ISqlExecuter>().ExecuteSql(new[]
{
"DELETE FROM Test13.Old2;",
"DELETE FROM Test13.Old1;",
"INSERT INTO Test13.Old1 (ID, IDOld1, Name) SELECT '" + GuidA + "', 11, 'a';",
"INSERT INTO Test13.Old1 (ID, IDOld1, Name) SELECT '" + GuidB + "', 12, 'b';",
"INSERT INTO Test13.Old2 (ID, IDOld2, Name, Old1ID, Same) SELECT NEWID(), 21, 'ax', 11, 'sx'",
"INSERT INTO Test13.Old2 (ID, IDOld2, Name, Old1ID, Same) SELECT NEWID(), 22, 'ay', 11, 'sy'"
});
}
private static void CheckColumns(UnitOfWorkScope scope, string expectedColumns, string schema, string table)
{
var sqlExecuter = scope.Resolve <ISqlExecuter>();
var actualColumns = new List <string>();
sqlExecuter.ExecuteReader(
"SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = '" + schema + "' AND TABLE_NAME = '" + table + "'",
reader => actualColumns.Add(reader[0].ToString()));
Assert.AreEqual(
TestUtility.DumpSorted(expectedColumns.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries)),
TestUtility.DumpSorted(actualColumns), schema + "." + table);
}
private static List <Tuple <Guid, Guid> > ReadConceptDependencies(IEnumerable <Guid> conceptsId, UnitOfWorkScope scope)
{
var dependencies = new List <Tuple <Guid, Guid> >();
string ids = string.Join(", ", conceptsId.Select(id => SqlUtility.QuoteGuid(id)));
scope.Resolve <ISqlExecuter>().ExecuteReader(
"SELECT DependsOnID, DependentID FROM Rhetos.AppliedConceptDependsOn"
+ " WHERE DependentID IN (" + ids + ")"
+ " AND DependsOnID IN (" + ids + ")",
reader => dependencies.Add(Tuple.Create(reader.GetGuid(0), reader.GetGuid(1))));
return(dependencies);
}
private static Guid ReadConceptId(string conceptInfoKey, UnitOfWorkScope scope)
{
Guid id = Guid.Empty;
scope.Resolve <ISqlExecuter>().ExecuteReader(
"SELECT ID FROM Rhetos.AppliedConcept WHERE ConceptInfoKey = " + SqlUtility.QuoteText(conceptInfoKey),
reader => id = reader.GetGuid(0));
if (id == Guid.Empty)
{
throw new ApplicationException("Cannot find applied concept '" + conceptInfoKey + "'.");
}
return(id);
}
private static void CheckCreatedDate(UnitOfWorkScope scope, DateTime start, DateTime finish)
{
start = new DateTime(start.Year, start.Month, start.Day, start.Hour, start.Minute, start.Second); // ORM may trim milliseconds.
var repository = scope.Resolve <Common.DomRepository>();
DateTime?generatedCreationTime = repository.TestAuditable.Simple.Load().Single().Started;
Assert.IsNotNull(generatedCreationTime, "Generated CreationTime is null.");
var msg = "Generated CreationTime (" + generatedCreationTime.Value.ToString("o") + ") should be between " + start.ToString("o") + " and " + finish.ToString("o") + ".";
Assert.IsTrue(start <= generatedCreationTime.Value && generatedCreationTime.Value <= finish, msg);
Console.WriteLine(msg);
}
private static void DeleteOldData(UnitOfWorkScope scope)
{
scope.Resolve <ISqlExecuter>().ExecuteSql(new[]
{
@"DELETE FROM Common.AutoCodeCache WHERE Entity LIKE 'TestAutoCodeCached.%';
DELETE FROM TestAutoCodeCached.ReferenceGroup;
DELETE FROM TestAutoCodeCached.ShortReferenceGroup;
DELETE FROM TestAutoCodeCached.Grouping;
DELETE FROM TestAutoCodeCached.StringGroup;
DELETE FROM TestAutoCodeCached.IntGroup;
DELETE FROM TestAutoCodeCached.Simple;
DELETE FROM TestAutoCodeCached.DoubleAutoCode;
DELETE FROM TestAutoCodeCached.DoubleAutoCodeWithGroup;"
});
}
public static Type[] GetSortedInitializers(UnitOfWorkScope scope)
{
// The plugins in the container are sorted by their dependencies defined in ExportMetadata attribute (static typed):
var initializers = scope.Resolve <IPluginsContainer <IServerInitializer> >().GetPlugins();
// Additional sorting by loosely-typed dependencies from the Dependencies property:
var initNames = initializers.Select(init => init.GetType().FullName).ToList();
var initDependencies = initializers.SelectMany(init => (init.Dependencies ?? Array.Empty <string>()).Select(x => Tuple.Create(x, init.GetType().FullName)));
Graph.TopologicalSort(initNames, initDependencies);
var sortedInitializers = initializers.ToArray();
Graph.SortByGivenOrder(sortedInitializers, initNames.ToArray(), init => init.GetType().FullName);
return(sortedInitializers.Select(initializer => initializer.GetType()).ToArray());
}
private static string ReportCommandResult(UnitOfWorkScope scope, ReadCommandInfo info, bool sort = false)
{
var commands = scope.Resolve <IIndex <Type, IEnumerable <ICommandImplementation> > >();
var readCommand = (ReadCommand)commands[typeof(ReadCommandInfo)].Single();
var result = (ReadCommandResult)readCommand.Execute(info).Data.Value;
var items = ((IEnumerable <TestQueryDataStructureCommand.E>)result.Records).Select(item => item.Name);
if (sort)
{
items = items.OrderBy(x => x);
}
var report = string.Join(", ", items) + " /" + result.TotalCount.Value;
Console.WriteLine(report);
return(report);
}
private static void DeleteOldData(UnitOfWorkScope scope)
{
scope.Resolve <ISqlExecuter>().ExecuteSql(new[]
{
@"DELETE FROM TestAutoCode.ReferenceGroup;
DELETE FROM TestAutoCode.ShortReferenceGroup;
DELETE FROM TestAutoCode.Grouping;
DELETE FROM TestAutoCode.StringGroup;
DELETE FROM TestAutoCode.IntGroup;
DELETE FROM TestAutoCode.BoolGroup;
DELETE FROM TestAutoCode.Simple;
DELETE FROM TestAutoCode.DoubleAutoCode;
DELETE FROM TestAutoCode.DoubleAutoCodeWithGroup;
DELETE FROM TestAutoCode.IntegerAutoCode;
DELETE FROM TestAutoCode.MultipleGroups;"
});
}
private static DateTime DbTime(UnitOfWorkScope scope)
{
return(SqlUtility.GetDatabaseTime(scope.Resolve <ISqlExecuter>()));
}
public EntityHelper(UnitOfWorkScope scope)
{
_executionContext = scope.Resolve <Common.ExecutionContext>();
_repository = scope.Resolve <Common.DomRepository>();
}
public T Resolve<T>()
{
InitializeUnitOfWorkScope();
return _transactionScope.Resolve<T>();
}
public T Resolve <T>()
{
return(unitOfWorkScope.Resolve <T>());
}
