public static Boolean IsModel(Type t)
{
var table_attribute = ModelCache.GetTableAttribute(t);
var column_attributes = ModelCache.GetColumnMembers(t);
return(table_attribute != null && column_attributes != null && column_attributes.Any());
}
public void DeepPopulate(object instance, Type thisType, Member rootMember = null, ReferencedObjectMember parentMember = null, Dictionary <Type, Dictionary <Object, Object> > objectLookups = null)
{
if (HasReferencedObjectMembers || parentMember != null)
{
var members = ModelCache.GetColumnMembers(thisType);
foreach (ColumnMember col in members)
{
var columnName = col.Name;
if (parentMember != null)
{
columnName = String.Format("{0}.{1}", parentMember.FullyQualifiedName, col.Name);
}
col.SetValue(instance, Get(col, columnName));
}
rootMember = rootMember ?? new RootMember(thisType);
foreach (ReferencedObjectMember rom in Model.GenerateMembers(thisType, rootMember, parentMember).Where(m => m is ReferencedObjectMember && !m.AnyParent(p => p is ChildCollectionMember)))
{
var type = rom.Type;
if (!rom.IsLazy)
{
var newObject = ReflectionHelper.GetNewObject(type);
DeepPopulate(newObject, type, rootMember, rom, objectLookups: objectLookups); //recursion.
if (objectLookups != null)
{
if (!objectLookups.ContainsKey(rom.Type))
{
objectLookups.Add(rom.Type, new Dictionary <Object, Object>());
}
var pkv = Model.InstancePrimaryKeyValue(rom.Type, newObject);
if (pkv != null && !objectLookups[rom.Type].ContainsKey(pkv))
{
objectLookups[rom.Type].Add(pkv, newObject);
rom.Property.SetValue(instance, newObject);
}
else
{
var existingObject = objectLookups[rom.Type][pkv];
rom.Property.SetValue(instance, existingObject);
}
}
else
{
rom.Property.SetValue(instance, newObject);
}
}
else
{
var mi = typeof(Model).GetMethod("GenerateLazyReferencedObjectMember");
var genericMi = mi.MakeGenericMethod(rom.UnderlyingGenericType);
var lazy = genericMi.Invoke(null, new Object[] { rom, instance });
rom.SetValue(instance, lazy);
}
}
if (HasChildCollectionMembers)
{
foreach (ChildCollectionMember cm in Model.GenerateMembers(thisType, rootMember, parentMember).Where(m => m is ChildCollectionMember && m.IsLazy))
{
var mi = typeof(Model).GetMethod("GenerateLazyChildCollectionMember");
var genericMi = mi.MakeGenericMethod(cm.UnderlyingGenericType);
var lazy = genericMi.Invoke(null, new Object[] { cm, instance });
cm.SetValue(instance, lazy);
}
}
}
else
{
SetInstanceValues(instance);
}
if (HasChildCollectionMembers && objectLookups != null)
{
if (!objectLookups.ContainsKey(thisType))
{
objectLookups.Add(thisType, new Dictionary <Object, Object>());
}
var pkv = Model.InstancePrimaryKeyValue(thisType, instance);
if (pkv != null && !objectLookups[thisType].ContainsKey(pkv))
{
objectLookups[thisType].Add(pkv, instance);
}
}
}
/// <summary>
/// Create an instance of <paramref name="myObject"/> in the database.
/// </summary>
/// <param name="myObject">Object to create</param>
/// <remarks>Will fill the objects primary key property if it is set to auto increment.</remarks>
public static void Create(object myObject)
{
Type myObjectType = myObject.GetType();
if (!Model.IsModel(myObjectType))
{
throw new SchemaMetadataException(String.Format("{0} : Model is Invalid", myObjectType.ToString()));
}
if (ReflectionHelper.HasInterface(myObjectType, typeof(IPreCreate)))
{
((IPreCreate)myObject).PreCreate();
}
if (ReflectionHelper.HasInterface(myObjectType, typeof(IAuditable)))
{
((IAuditable)myObject).DoAudit(DatabaseAction.Create, myObject);
}
StringBuilder command = new StringBuilder();
var connectionName = Model.ConnectionName(myObjectType);
using (var cmd = Execute.Command(connectionName))
{
cmd.CommandType = System.Data.CommandType.Text;
command.Append("INSERT INTO " + Model.TableNameFullyQualified(myObjectType) + " (");
List <String> columnNames = new List <String>();
foreach (var cm in ModelCache.GetColumnMembers(myObjectType))
{
if (!cm.ColumnAttribute.IsForReadOnly && !(Model.HasAutoIncrementColumn(myObjectType) && cm.IsPrimaryKey))
{
columnNames.Add(cm.Name);
}
}
command.Append(string.Join(", ", columnNames.Select(columnName => String.Format("[{0}]", columnName))));
command.Append(") VALUES (");
command.Append(string.Join(", ", columnNames.Select(s => "@" + s)));
command.Append(");");
foreach (var cm in ModelCache.GetColumnMembers(myObjectType))
{
if (!cm.ColumnAttribute.IsForReadOnly && !(Model.HasAutoIncrementColumn(myObjectType) && cm.IsPrimaryKey))
{
AddColumnParameter(cm, myObject, cmd, connectionName);
}
}
if (Model.HasAutoIncrementColumn(myObjectType))
{
command.Append("SELECT @@IDENTITY;");
cmd.CommandText = command.ToString();
object o = cmd.ExecuteScalar();
if (o != null && !(o is DBNull))
{
var aicm = Model.AutoIncrementColumn(myObjectType);
aicm.SetValue(myObject, Convert.ChangeType(o, aicm.Property.PropertyType));
}
}
else
{
cmd.CommandText = command.ToString();
cmd.ExecuteNonQuery();
}
}
if (ReflectionHelper.HasInterface(myObjectType, typeof(IPostCreate)))
{
((IPostCreate)myObject).PostCreate();
}
}
/// <summary>
/// Update the <paramref name="myObject"/>.
/// </summary>
/// <param name="myObject"></param>
/// <remarks>Updates every property marked as a column.</remarks>
public static void Update(object myObject)
{
Type myObjectType = myObject.GetType();
if (ReflectionHelper.HasInterface(myObjectType, typeof(IAuditable)))
{
var previous = ((IAuditable)myObject).AuditGetPrevious(myObject);
((IAuditable)myObject).DoAudit(DatabaseAction.Update, myObject, previous);
}
if (ReflectionHelper.HasInterface(myObjectType, typeof(IPreUpdate)))
{
((IPreUpdate)myObject).PreUpdate();
}
StringBuilder command = new StringBuilder();
var connectionName = Model.ConnectionName(myObjectType);
using (var cmd = Execute.Command(connectionName))
{
cmd.CommandType = System.Data.CommandType.Text;
command.Append("UPDATE ");
command.Append(Model.TableNameFullyQualified(myObjectType));
command.Append(" SET ");
List <String> variables = new List <String>();
foreach (var cm in Model.ColumnsNonPrimaryKey(myObjectType))
{
if (!cm.ColumnAttribute.IsForReadOnly)
{
variables.Add(cm.Name);
}
}
command.Append(string.Join(", ", variables.Select(variableName => String.Format("[{0}] = @{0}", variableName))));
command.Append(" WHERE ");
variables = new List <String>();
foreach (var cm in Model.ColumnsPrimaryKey(myObjectType))
{
variables.Add(cm.Name);
}
command.Append(string.Join(" and ", variables.Select(variableName => String.Format("[{0}] = @{0}", variableName))));
//parameters
foreach (var cm in ModelCache.GetColumnMembers(myObjectType))
{
if (!cm.IsForReadOnly)
{
AddColumnParameter(cm, myObject, cmd, connectionName);
}
}
cmd.CommandText = command.ToString();
cmd.ExecuteNonQuery();
}
if (ReflectionHelper.HasInterface(myObjectType, typeof(IPostUpdate)))
{
((IPostUpdate)myObject).PostUpdate();
}
}
public static ColumnMember[] ColumnsPrimaryKey(Type t)
{
return(ModelCache.GetColumnMembers(t).Where(cm => cm.IsPrimaryKey).ToArray());
}
