public IMCollection <DbRow> ExecuteNativeQuery(string query, Action <DbCommand, Func <string, DbType, DbParameter> > parametersConfiguration, int commandTimeout = 30)
{
return(ExecuteOnSafeSqlCommand(query, command =>
{
parametersConfiguration(command, NewParameter);
IMCollection <DbRow> dbRows = new MCollection <DbRow>();
command.CommandTimeout = commandTimeout;
var reader = command.ExecuteReader();
while (reader.Read())
{
DbRow row = new DbRow();
for (int ii = 0; ii <= reader.FieldCount - 1; ii++)
{
DbColumn column = new DbColumn(reader.GetFieldType(ii),
reader.GetName(ii),
reader.GetValue(ii));
row.Columns.Add(column);
}
dbRows.Add(row);
}
reader.Close();
return dbRows;
}));
}
public void Matches_should_detect_multiple_interface_enumerators()
{
var subj = new HaveKeyMatcher <string>("hello");
var items = new MCollection();
Assert.True(subj.Matches(items));
}
public User()
{
FirstName = "";
LastName = "";
Email = "";
Idiom = new Idiom();
Groups = new MCollection <Group>();
Permissions = new MCollection <Permission>();
}
public IPersistenceState ToHandle(IEntity anEntity)
{
IMCollection <IPersistenceState> states = new MCollection <IPersistenceState>
{
new PersistedState(),
new NotPersistedState()
};
return(states.Filter(state => state.CanHandle(anEntity)).GetFirst());
}
public IMCollection <ITestSuite> GetAllTestSuites(string moduleToTest)
{
IMCollection <ITestSuite> suites = new MCollection <ITestSuite>();
GetDerivedTypes(typeof(TestSuite), Assembly.Load(moduleToTest))
.ForEach(type => {
suites.Add((TestSuite)Activator.CreateInstance(type));
});
return(suites);
}
public static ISessionState ToHandleConnectionState(IConnection aConnection)
{
IMCollection <ISessionState> states = new MCollection <ISessionState>
{
new SessionStateOpen(),
new SessionStateClose()
};
return(states.Filter(state => state.CanHandle(aConnection)).GetFirst());
}
public IMCollection <Group> Insert(IMCollection <Group> groups)
{
IMCollection <Group> insertedPermissions = new MCollection <Group>();
groups.ForEach(group =>
{
int groupId = Insert(group);
insertedPermissions.Add(new Group()
{
Id = groupId, Description = group.Description, Permissions = group.Permissions
});
});
return(insertedPermissions);
}
public IMCollection <ITestSuite> GetTestsByConfiguration()
{
IMCollection <ITestSuite> suites = new MCollection <ITestSuite>();
_configuration.ForEach(suiteName => {
try {
Type type = Type.GetType(suiteName);
suites.Add((ITestSuite)Activator.CreateInstance(type));
} catch {
_logger.Error("TestSuite [" + suiteName + "] Not found");
}
});
return(suites);
}
public IMCollection <Permission> Insert(IMCollection <Permission> permissions)
{
IMCollection <Permission> insertedPermissions = new MCollection <Permission>();
permissions.ForEach(permission =>
{
int permissionId = Insert(permission);
insertedPermissions.Add(new Permission
{
Id = permissionId, Description = permission.Description
});
});
return(insertedPermissions);
}
private void CanTransformWithNullableValuesTest()
{
DbRow dbRow = new DbRow();
dbRow.Columns.Add(new DbColumn(typeof(string), "aColumn", null));
IMCollection <DbRow> dbRows = new MCollection <DbRow> {
dbRow
};
IResultTransformer <DummyClassToBeTransformed> resultTransformer = new ResultTransformer <DummyClassToBeTransformed>(dbRows);
IMCollection <DummyClassToBeTransformed> transformed = resultTransformer.Transform();
Assertion.AreEqual(1, transformed.Count);
Assertion.AreEqual(null, transformed[0].AName);
}
private void CanTransformIgnoringUnderscoreInColumnNameTest()
{
const string columnName = "A_NAME";
DbRow dbRow = new DbRow();
dbRow.Columns.Add(new DbColumn(typeof(string), columnName, DummyStringValue));
IMCollection <DbRow> dbRows = new MCollection <DbRow> {
dbRow
};
IResultTransformer <DummyClassToBeTransformed> resultTransformer = new ResultTransformer <DummyClassToBeTransformed>(dbRows);
IMCollection <DummyClassToBeTransformed> transformed = resultTransformer.Transform();
Assertion.AreEqual(DummyStringValue, transformed[0].AName);
}
private void CanTransformAnIntTypeTest()
{
const string columnName = "aInt";
DbRow dbRow = new DbRow();
dbRow.Columns.Add(new DbColumn(typeof(int), columnName, DummyIntValue));
IMCollection <DbRow> dbRows = new MCollection <DbRow> {
dbRow
};
IResultTransformer <DummyClassToBeTransformed> resultTransformer = new ResultTransformer <DummyClassToBeTransformed>(dbRows);
IMCollection <DummyClassToBeTransformed> transformed = resultTransformer.Transform();
Assertion.AreEqual(DummyIntValue, transformed[0].AInt);
}
private void CanTransformABigIntegerTypeTest()
{
const string columnName = "aBigInteger";
DbRow dbRow = new DbRow();
dbRow.Columns.Add(new DbColumn(typeof(BigInteger), columnName, _dummyBigIntegerValue));
IMCollection <DbRow> dbRows = new MCollection <DbRow> {
dbRow
};
IResultTransformer <DummyClassToBeTransformed> resultTransformer = new ResultTransformer <DummyClassToBeTransformed>(dbRows);
IMCollection <DummyClassToBeTransformed> transformed = resultTransformer.Transform();
Assertion.AreEqual(_dummyBigIntegerValue, transformed[0].ABigInteger);
}
private void CanTransformWithNotRecognizedColumnsTest()
{
const string dummyColumnName = "dummyName";
DbRow dbRow = new DbRow();
dbRow.Columns.Add(new DbColumn(typeof(string), dummyColumnName, DummyStringValue));
IMCollection <DbRow> dbRows = new MCollection <DbRow> {
dbRow
};
IResultTransformer <DummyClassToBeTransformed> resultTransformer = new ResultTransformer <DummyClassToBeTransformed>(dbRows);
IMCollection <DummyClassToBeTransformed> transformed = resultTransformer.Transform();
Assertion.AreEqual(null, transformed[0].AName);
}
private void CanTransformAResultSetWithMoreThanOneItemTest()
{
DbRow dbRow1 = new DbRow();
dbRow1.Columns.Add(new DbColumn(typeof(string), "aColumn", null));
DbRow dbRow2 = new DbRow();
dbRow2.Columns.Add(new DbColumn(typeof(string), "aColumn", null));
IMCollection <DbRow> dbRows = new MCollection <DbRow> {
dbRow1, dbRow2
};
IResultTransformer <DummyClassToBeTransformed> resultTransformer = new ResultTransformer <DummyClassToBeTransformed>(dbRows);
Assertion.AreEqual(2, resultTransformer.Transform().Count);
}
private IMCollection <Type> GetDerivedTypes(Type baseType, Assembly assembly)
{
// Get all types from the given assembly
Type[] types = assembly.GetTypes();
IMCollection <Type> derivedTypes = new MCollection <Type>();
for (int i = 0, count = types.Length; i < count; i++)
{
Type type = types[i];
if (IsSubclassOf(type, baseType))
{
// The current type is derived from the base type,
// so add it to the list
derivedTypes.Add(type);
}
}
return(derivedTypes);
}
public IMCollection <TEntity> Transform()
{
IMCollection <TEntity> resultObjects = new MCollection <TEntity>();
_dbRows.ForEach(row =>
{
TEntity entity = new TEntity();
row.Columns.ForEach(column =>
{
string columnName = column.Name?.ToLower();
if (column.Value == DBNull.Value)
{
return;
}
if (Predefined.Like(columnName, "%_id"))
{
//Getting relationship instance
PropertyInfo entityRelationshipInfo = GetPrivatePropertyInfo(typeof(TEntity), columnName?.Split("_id")[0]);
object entityRelationshipInstance = entityRelationshipInfo.GetValue(entity);
//Setting up relationship id
PropertyInfo entityRelationshipIdInfo = GetPrivatePropertyInfo(entityRelationshipInstance.GetType(), "id");
entityRelationshipIdInfo?.SetValue(entityRelationshipInstance, Convert.ChangeType(column.Value, column.Type));
}
else
{
columnName = columnName?.Replace("_", "");
PropertyInfo propertyInfo = GetPrivatePropertyInfo(typeof(TEntity), columnName);
propertyInfo?.SetValue(entity, Convert.ChangeType(column.Value, column.Type));
}
});
resultObjects.Add(entity);
});
return(resultObjects);
}
internal ArrayObject(MValue mv, MCollection parent)
{
_array.InitInSlot(mv, parent);
_threadSafety = SetupThreadSafety();
}
internal DictionaryObject(MValue mv, MCollection parent)
{
_dict.InitInSlot(mv, parent);
_threadSafety = SetupThreadSafety();
}
internal static unsafe bool ValueWouldChange(object newValue, MValue oldValue, MCollection container)
{
// As a simplification we assume that array and fict values are always different, to avoid
// a possibly expensive comparison
var oldType = Native.FLValue_GetType(oldValue.Value);
if (oldType == FLValueType.Undefined || oldType == FLValueType.Dict || oldType == FLValueType.Array)
{
return(true);
}
switch (newValue)
{
case ArrayObject arr:
case DictionaryObject dict:
return(true);
default:
var oldVal = oldValue.AsObject(container);
return(!newValue?.Equals(oldVal) ?? oldVal != null);
}
}
internal MutableDictionaryObject(MValue mv, MCollection parent)
: base(mv, parent)
{
}
public Group()
{
Description = "";
Permissions = new MCollection <Permission>();
}
