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>(); }