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