public override void ApplyOnMember(EntityModelBuilder builder)
{
// It is initially assigned EntityRef
if (!builder.Model.IsEntity(HostMember.DataType))
{
builder.Log.LogError
($"{this.GetType()} may be used only on properties that reference other entities. Property: {HostRef}");
return;
}
HostMember.Kind = EntityMemberKind.Transient;
HostMember.Flags |= EntityMemberFlags.FromOneToOneRef;
_targetEntity = builder.Model.GetEntityInfo(HostMember.DataType);
Util.Check(_targetEntity != null, "Target entity not found: {0}", HostMember.DataType.Name);
//check that PK of target entity points back to 'this' entity
var targetPkMembers = _targetEntity.PrimaryKey.KeyMembers;
var isOk = targetPkMembers.Count == 1 && targetPkMembers[0].Member.DataType == HostEntity.EntityType;
if (!isOk)
{
builder.Log.LogError(
$"OneToOne property {HostRef}: target entity must have Primary key pointing back to host entity {HostEntity.EntityType}.");
return;
}
HostMember.GetValueRef = GetValue;
HostMember.SetValueRef = SetValue;
}//method
public override void ApplyOnMember(EntityModelBuilder builder)
{
if ((this.Options & SizeOptions.AutoTrim) != 0)
{
HostMember.Flags |= EntityMemberFlags.AutoTrim;
}
// Check size code and lookup in tables
if (!string.IsNullOrEmpty(this.SizeCode))
{
var sizeTable = builder.Model.App.SizeTable;
//If there is size code, look it up in SizeTable; first check module-specific value, then global value for the code
int size;
//check full code with module's namespace prefix or short size code
var fullCode = Sizes.GetFullSizeCode(HostMember.Entity.EntityType.Namespace, this.SizeCode);
if (!sizeTable.TryGetValue(fullCode, out size) && !sizeTable.TryGetValue(this.SizeCode, out size))
{
builder.Log.LogError(
$"Size code '{SizeCode}' not found, entity member: {HostRef}");
return;
}
HostMember.Size = size;
return;
}
//If size is specified explicitly, use it
if (this.Size > 0)
{
HostMember.Size = this.Size;
return;
}
}
public EntityApp Build(DbFirstConfig config)
{
_config = config;
_app = new EntityApp();
var log = _app.SystemLog;
_dbSettings = new DbSettings(_config.Driver, DbOptions.Default, _config.ConnectionString);
_dbSettings.SetSchemas(_config.Schemas);
var modelLoader = _config.Driver.CreateDbModelLoader(_dbSettings, log);
_dbModel = modelLoader.LoadModel();
Util.Check(_dbModel.Tables.Count() > 0, "No tables found in the database. Code generation aborted.");
// Prepare type generator
_tempNamespace = "_dummy_" + _callCount++; // artificial unique namespace for dummy interface types
// Construct model setup and model
GenerateModulesAndAreas();
_entityModel = new EntityModel(_app);
EntityModelBuilder.SetModel(_app, _entityModel);
_entityModel.ClassesAssembly = new EntityClassesAssembly();
//generate entities and members
GenerateEntities();
SetupPrimaryKeys();
GenerateReferenceMembers();
CreateIndexes();
SetupKeyMembers();
return(_app);
}
public override void ApplyOnMember(EntityModelBuilder builder)
{
var namesArr = StringHelper.SplitNames(this.MemberNames);
foreach (var name in namesArr)
{
var targetMember = HostEntity.GetMember(name);
if (targetMember == null)
{
builder.Log.LogError($"Member {name} referenced in DependsOn attribute on member {HostRef} not found.");
return;
}
//add this member to DependentMembers array of targetMember
if (targetMember.DependentMembers == null)
{
targetMember.DependentMembers = new EntityMemberInfo[] { HostMember }
}
;
else
{
var mList = targetMember.DependentMembers.ToList();
mList.Add(HostMember);
targetMember.DependentMembers = mList.ToArray();
}
} //foreach name
} // method
public override void ApplyOnEntity(EntityModelBuilder builder)
{
if (!string.IsNullOrWhiteSpace(this.Name))
{
HostEntity.Name = this.Name;
}
HostEntity.TableName = this.TableName;
}
}//method
//This is a special case - OrderBy attribute specifies the order of entities in list property.
public override void ApplyOnMember(EntityModelBuilder builder)
{
var entity = HostEntity;
var listInfo = HostMember.ChildListInfo;
EntityModelBuilderHelper.TryParseKeySpec(HostMember.ChildListInfo.TargetEntity, this.OrderByList, builder.Log,
out listInfo.OrderBy, ordered: true, specHolder: HostEntity);
}
public override void ApplyOnMember(EntityModelBuilder builder)
{
//Set interceptors
HostMember.Entity.Events.Modified += Events_ModifiedDeleted;
HostMember.Entity.Events.Deleting += Events_ModifiedDeleted;
_defaultValueSetter = HostMember.SetValueRef;
HostMember.SetValueRef = SetMemberValue;
}
public override void ApplyOnMember(EntityModelBuilder builder)
{
HostMember.Flags |= EntityMemberFlags.Utc;
//Inject interceptor
_defaultGetter = HostMember.GetValueRef;
_defaultSetter = HostMember.SetValueRef;
HostMember.GetValueRef = GetValueInterceptor;
HostMember.SetValueRef = SetValueInterceptor;
}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
var modelConfigurator = new EntityModelBuilder(modelBuilder);
base.OnModelCreating(modelBuilder);
// if (this.modelBuilder != null)
// {
// this.modelBuilder.Build();
// }
}
public override void ApplyOnMember(EntityModelBuilder builder)
{
HostMember.Flags |= EntityMemberFlags.Nullable;
if (HostMember.DataType.IsValueType)
{
HostMember.Flags |= EntityMemberFlags.ReplaceDefaultWithNull;
HostMember.GetValueRef = MemberValueGettersSetters.GetValueTypeReplaceNullWithDefault;
HostMember.SetValueRef = MemberValueGettersSetters.SetValueTypeReplaceDefaultWithNull;
}
}
public override void ApplyOnEntity(EntityModelBuilder builder)
{
_method = this.MethodClass.GetMethod(this.MethodName);
if (_method == null)
{
builder.Log.LogError($"Method {MethodName} specified as Validation method for entity {HostRef} not found in type {MethodClass}.");
return;
}
HostEntity.Events.ValidatingChanges += Events_Validating;
}
protected virtual void InitApp()
{
Status = EntityAppStatus.Initializing;
SetupLogFileWriters();
ActivationLog.WriteMessage("Initializing EntityApp {0}.====================================", this.AppName);
this.AppEvents.OnInitializing(EntityAppInitStep.Initializing);
//Check dependencies
foreach (var mod in this.Modules)
{
var depList = mod.GetDependencies();
foreach (var dep in depList)
{
var ok = Modules.Any(m => dep.IsTypeOrSubType(m));
if (!ok)
{
ActivationLog.LogError($"Module {mod.Name} requires dependent module {dep} which is not included in the app.");
}
}
}
CheckActivationErrors();
//Build model
var builder = new EntityModelBuilder(this);
builder.BuildModel();
CheckActivationErrors();
//Notify modules that entity app is constructed
foreach (var module in this.Modules)
{
module.Init();
}
//init services; note that service might be registered more than once, under different interface
var servList = this.GetAllServices().Distinct().ToList();
for (int i = 0; i < servList.Count; i++)
{
var service = servList[i];
var iServiceInit = service as IEntityServiceBase;
if (iServiceInit != null)
{
iServiceInit.Init(this);
}
}
//complete initialization
this.AppEvents.OnInitializing(EntityAppInitStep.Initialized);
foreach (var module in this.Modules)
{
module.AppInitComplete();
}
builder.CheckErrors();
Status = EntityAppStatus.Initialized;
ActivationLog.WriteMessage("App {0} initialized.", this.AppName);
}
public override void ApplyOnEntity(EntityModelBuilder builder)
{
_method = this.MethodClass.GetMethod(this.MethodName);
if (_method == null)
{
builder.Log.Error("Method {0} specified as Validation method for entity {1} not found in type {2}",
this.MethodName, HostEntity.EntityType, this.MethodClass);
return;
}
HostEntity.Events.ValidatingChanges += Events_Validating;
}
/// <summary>
/// Override for configuring entity mapping.
/// </summary>
/// <param name="modelBuilder"></param>
protected internal override void OnModelBuilding(EntityModelBuilder modelBuilder)
{
modelBuilder.Entity <Address>(entity =>
{
//entity.ToTable( "Addresses" );
//entity.Column( p => p.AddressId )
// .IsKey();
});
base.OnModelBuilding(modelBuilder);
}
private void PopulateUsers()
{
Users.Clear();
var users = UserRepository.GetUsers();
foreach (var user in users)
{
var userViewModel = EntityModelBuilder.GetUserViewModel(user);
var role = UserRepository.GetUserRole(user.Id);
Enum.TryParse(role, out Role userRole);;
userViewModel.Role = userRole;
Users.Add(userViewModel);
}
}
public override void ApplyOnMember(EntityModelBuilder builder)
{
base.ApplyOnMember(builder);
var member = base.HostMember;
if (member.DataType != typeof(Guid) && member.DataType != typeof(Guid?))
{
builder.Log.Error("ActivityTrack attribute may be used only on Guid properties.");
return;
}
member.Flags |= EntityMemberFlags.IsSystem;
_defaultValue = (member.DataType == typeof(Guid)) ? Guid.Empty : (Guid?)null;
member.Entity.SaveEvents.SavingChanges += SaveEvents_SavingChanges;
}
public override void ApplyOnEntity(EntityModelBuilder builder)
{
var names = StringHelper.SplitNames(this.OldNames);
// add variation without leading 'I'
var allNames = new List <string>(names);
foreach (var n in names)
{
if (n.Length > 1 && n.StartsWith("I"))
{
allNames.Add(n.Substring(1));
}
}
HostEntity.OldNames = allNames.ToArray();
}
public override void ApplyOnMember(EntityModelBuilder builder)
{
base.ApplyOnMember(builder);
var member = base.HostMember;
var type = Nullable.GetUnderlyingType(member.DataType) ?? member.DataType;
if (type != typeof(long) && type != typeof(ulong))
{
builder.Log.LogError($"TransactionId attribute may be used only on properties of type long or ulong.");
return;
}
member.Flags |= EntityMemberFlags.IsSystem;
_defaultValue = (member.DataType == typeof(Guid)) ? Guid.Empty : (Guid?)null;
member.Entity.SaveEvents.SavingChanges += SaveEvents_SavingChanges;
}
private bool CheckDataType(EntityModelBuilder builder, params Type[] types)
{
var dt = HostMember.DataType;
if (dt.IsGenericType)
{
dt = dt.GetGenericArguments()[0]; // check for DateTime?
}
if (types.Contains(dt))
{
return(true);
}
builder.Log.Error("Entity member {0}.{1}: Auto({2}) attribute may be set only on member of type(s): {3}. ",
HostEntity, HostMember.MemberName, this.Type, string.Join(", ", types.Select(t => t.Name)));
return(false);
}
private void ProcessIndexIncludesAndFilters(IActivationLog log)
{
if (!string.IsNullOrWhiteSpace(this.Filter))
{
Key.IndexFilter = EntityModelBuilder.ParseFilter(this.Filter, this.HostEntity, log);
}
// Check include fields
if (!string.IsNullOrWhiteSpace(this.IncludeMembers))
{
if (EntityModelBuilderHelper.TryParseKeySpec(HostEntity, this.IncludeMembers, log,
out List <EntityKeyMemberInfo> keyMembers, ordered: false))
{
Key.IncludeMembers.AddRange(keyMembers.Select(km => km.Member));
}
}
}
private bool CheckDataType(EntityModelBuilder builder, params Type[] types)
{
var dt = HostMember.DataType;
if (dt.IsGenericType)
{
dt = dt.GetGenericArguments()[0]; // check for DateTime?
}
if (types.Contains(dt))
{
return(true);
}
var okTypes = string.Join(", ", types.Select(t => t.Name));
builder.Log.LogError($"Entity member {HostRef}: Auto({this.Type}) attribute may be set only on member of type(s): {okTypes}. ");
return(false);
}
public override void ApplyOnMember(EntityModelBuilder builder)
{
var names = StringHelper.SplitNames(this.GroupNames);
foreach (var name in names)
{
if (string.IsNullOrWhiteSpace(name))
{
continue;
}
var grp = HostEntity.GetPropertyGroup(name, create: true);
if (!grp.Members.Contains(HostMember))
{
grp.Members.Add(HostMember);
}
} //foreach
}
public override void ApplyOnMember(EntityModelBuilder builder)
{
if (!this.Persist)
{
HostMember.Kind = EntityMemberKind.Transient;
}
HostMember.Flags |= EntityMemberFlags.Computed;
var bFlags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
_method = this.MethodClass.GetMethod(this.MethodName, bFlags);
if (_method == null)
{
builder.Log.LogError($"Method {MethodName} for computed column {HostMember.MemberName} not found in type {this.MethodClass}");
return;
}
HostMember.GetValueRef = GetComputedValue;
HostMember.SetValueRef = MemberValueGettersSetters.DummySetValue;
}
public override void ApplyOnEntity(EntityModelBuilder builder)
{
var names = StringHelper.SplitNames(this.MemberNames);
foreach (var name in names)
{
var member = HostEntity.GetMember(name);
if (member == null)
{
builder.Log.Error("PropertyGroup '{0}', entity {1}: member {2} not found.", this.GroupName, HostEntity.Name, name);
return;
}
var grp = HostEntity.GetPropertyGroup(this.GroupName, create: true);
if (!grp.Members.Contains(member))
{
grp.Members.Add(member);
}
} //foreach
}
public override void ApplyOnMember(EntityModelBuilder builder)
{
if (!string.IsNullOrWhiteSpace(this.ColumnName))
{
HostMember.ColumnName = this.ColumnName;
}
if (!string.IsNullOrWhiteSpace(this.Default))
{
HostMember.ColumnDefault = this.Default;
}
HostMember.Scale = this.Scale;
if (this.Precision > 0)
{
HostMember.Precision = this.Precision;
}
if (this.Size != 0)
{
HostMember.Size = this.Size;
}
HostMember.ExplicitDbTypeSpec = this.DbTypeSpec?.ToLowerInvariant();
}
public override void ApplyOnEntity(EntityModelBuilder builder)
{
if (HostEntity.DefaultOrderBy != null)
{
builder.Log.Error("More than one OrderBy attribute in entity {0}.", HostEntity.Name);
}
if (!EntityModelBuilderHelper.TryParseKeySpec(HostEntity, this.OrderByList, builder.Log, out HostEntity.DefaultOrderBy,
ordered: true, specHolder: HostEntity))
{
return;
}
//Check that they are real cols
foreach (var ordM in HostEntity.DefaultOrderBy)
{
if (ordM.Member.Kind != EntityMemberKind.Column)
{
builder.Log.Error("Invalid property {0} in OrderBy attribute in entity {1} - must be a simple value column.",
ordM.Member.MemberName, HostEntity.Name);
}
}
}//method
public override void ApplyOnMember(EntityModelBuilder builder)
{
EntityInfo orderedEntity = null;
//determine the entity that is ordered
switch (HostMember.ChildListInfo.RelationType)
{
case EntityRelationType.ManyToOne:
orderedEntity = HostMember.ChildListInfo.TargetEntity;
break;
case EntityRelationType.ManyToMany:
orderedEntity = HostMember.ChildListInfo.LinkEntity;
break;
}
//check that there is a member
var orderMember = orderedEntity.GetMember(this.Property);
if (orderMember == null)
{
builder.Log.Error("Property '{0}' referenced in PersistOrderIn attribute on entity {1} not found in entity {2}.",
this.Property, HostEntity.Name, orderedEntity.Name);
return;
}
//current limitation - index property must be int32 only
if (orderMember.DataType != typeof(Int32))
{
builder.Log.Error("Invalid data type ({0}) for property '{1}' referenced in PersistOrderIn attribute on entity {2}: must be Int32.",
orderMember.DataType.Name, this.Property, HostEntity.EntityType);
return;
}
// Validation passed, assign order member
HostMember.ChildListInfo.PersistentOrderMember = orderMember;
// Make list order to be by orderMember
var listInfo = HostMember.ChildListInfo;
listInfo.OrderBy = new List <EntityKeyMemberInfo>();
listInfo.OrderBy.Add(new EntityKeyMemberInfo(orderMember, desc: false));
}
public override void ApplyOnMember(EntityModelBuilder builder)
{
if (HostMember.DataType != typeof(int))
{
builder.Log.LogError($"HashFor attribute can be used only on int properties. Entity/property: {HostRef}.");
return;
}
_hashedMember = HostEntity.GetMember(this.PropertyName);
if (_hashedMember == null)
{
builder.Log.LogError($"Property {PropertyName} referenced in HashFor attribute on property {HostRef} not found.");
return;
}
if (_hashedMember.DataType != typeof(string))
{
builder.Log.LogError($"HashFor attribute on property {HostRef}: target property must be of string type.");
return;
}
_oldSetter = _hashedMember.SetValueRef;
_hashedMember.SetValueRef = OnSettingValue;
_hashingService = builder.Model.App.GetService <IHashingService>();
}
public override void ApplyOnEntity(EntityModelBuilder builder)
{
if (this.MethodClass != null && this.MethodName != null)
{
_customMethodInfo = this.MethodClass.GetMethod(MethodName);
if (_customMethodInfo == null)
{
builder.Log.Error("Method {0} specified as Display method for entity {1} not found in type {2}",
MethodName, HostEntity.EntityType, this.MethodClass);
return;
}
HostEntity.DisplayMethod = InvokeCustomDisplay;
return;
}
//Check if Format provided
if (string.IsNullOrEmpty(this.Format))
{
builder.Log.Error("Invalid Display attribute on entity {0}. You must provide method reference or non-empty Format value.",
HostEntity.EntityType);
return;
}
//Parse Format value, build argIndexes from referenced property names
StringHelper.TryParseTemplate(this.Format, out _adjustedFormat, out _propNames);
//verify and build arg indexes
foreach (var prop in _propNames)
{
//it might be dotted sequence of props; we check only first property
var propSeq = prop.SplitNames('.');
var member = HostEntity.GetMember(propSeq[0]);
if (member == null)
{
builder.Log.Error("Invalid Format expression in Display attribute on entity {0}. Property {1} not found.",
HostEntity.EntityType, propSeq[0]);
return;
}
}//foreach
HostEntity.DisplayMethod = GetDisplayString;
}
public override void ApplyOnMember(EntityModelBuilder builder)
{
EntityInfo orderedEntity = null;
//determine the entity that is ordered
switch (HostMember.ChildListInfo.RelationType)
{
case EntityRelationType.ManyToOne:
orderedEntity = HostMember.ChildListInfo.TargetEntity;
break;
case EntityRelationType.ManyToMany:
orderedEntity = HostMember.ChildListInfo.LinkEntity;
break;
}
//check that there is a member
var orderMember = orderedEntity.GetMember(this.Property);
if (orderMember == null)
{
builder.Log.LogError(
$"Property '{Property}' referenced in PersistOrderIn attribute on {HostRef} not found in entity {orderedEntity.Name}.");
return;
}
if (!orderMember.DataType.IsInt())
{
builder.Log.LogError(
$"Invalid data type ({orderMember.DataType}) in PersistOrderIn attribute on '{HostRef}' must be Int32.");
return;
}
// Validation passed, assign order member
HostMember.ChildListInfo.PersistentOrderMember = orderMember;
// Make list order to be by orderMember
var listInfo = HostMember.ChildListInfo;
listInfo.OrderBy = new List <EntityKeyMemberInfo>();
listInfo.OrderBy.Add(new EntityKeyMemberInfo(orderMember, desc: false));
}
