/// <summary> /// Add a method to the definition for the entity. /// </summary> /// <param name="entity"></param> /// <param name="method"></param> private static void AddMethodToEntity(OrmEntity entity, MethodDescription method) { OrmEntityMethod targetMethod = null; targetMethod = method.CreateMethod(entity); OrmMethodTarget targetStep = method.CreateTarget(AUTOWIRE_HEADER); TargetMethodCollection targetColl = null; switch (method.StepType) { case TargetStepType.PreExecute: targetColl = targetMethod.PreExecuteTargets; break; case TargetStepType.PostFlush: targetColl = targetMethod.PostFlushTargets; break; case TargetStepType.PostExecute: targetColl = targetMethod.PostExecuteTargets; break; case TargetStepType.Primary: default: targetColl = targetMethod.MethodTargets; break; } targetColl.Add(targetStep); entity.Methods.Add(targetMethod); }
public RelationshipInfo(OrmEntity parentEntity, OrmEntity childEntity, bool isInverted) { _relationship = null; _isOneToMany = false; _propertyName = (isInverted ? parentEntity : childEntity).Name; }
protected override CodeTemplate GetOutputTemplate(OrmEntity entity) { var model = (OrmModel)entity.Model; var templates = model.GetCodeTemplates(null, "SDataClientEntity"); if (templates.Count > 0) return templates[0]; throw new BuildException("Missing sdata client entity code generation template"); }
protected override CodeTemplate GetOutputTemplate(OrmEntity entity) { var model = (OrmModel)entity.Model; var templates = model.GetCodeTemplates(null, "SDataClientEntity"); if (templates.Count > 0) { return(templates[0]); } throw new BuildException("Missing sdata client entity code generation template"); }
/// <summary> /// Create a new method or return existing method if appropriate /// </summary> /// <param name="entity"></param> /// <returns></returns> public OrmEntityMethod CreateMethod(OrmEntity entity) { if (MethodType == Sage.Platform.Orm.Entities.MethodType.Rule) { OrmEntityMethod method = new OrmEntityMethod { ActionType = ActionType.None, ReturnType = ReturnType, MethodName = Name, MethodType = MethodType }; if (ParameterTypes != null && ParameterTypes.Length > 0) { //MethodParameterCollection paramColl = new MethodParameterCollection(method); foreach (ParamDescription p in ParameterTypes) { method.MethodParameters.Add(new OrmEntityMethodParam { ParamName = p.Name, ParamType = p.ParamType }); } } return(method); } else if (MethodType == Sage.Platform.Orm.Entities.MethodType.CrudEvent) { switch (EventType) { case AutoWire.EventType.BeforeUpdate: return(entity.OnBeforeUpdateMethod); case AutoWire.EventType.AfterUpdate: return(entity.OnAfterUpdateMethod); case AutoWire.EventType.BeforeInsert: return(entity.OnBeforeInsertMethod); case AutoWire.EventType.AfterInsert: return(entity.OnAfterInsertMethod); case AutoWire.EventType.BeforeDelete: return(entity.OnBeforeDeleteMethod); default: throw new Exception("Invalid event type " + EventType + " for AutoWire method " + DeclaringType + "." + Name); } } else { throw new Exception("Unsupported method type " + MethodType + " for AutoWire method " + DeclaringType + "." + Name); } }
/// <summary> /// Create a new method or return existing method if appropriate /// </summary> /// <param name="entity"></param> /// <returns></returns> public OrmEntityMethod CreateMethod(OrmEntity entity) { if (MethodType == Sage.Platform.Orm.Entities.MethodType.Rule) { OrmEntityMethod method = new OrmEntityMethod { ActionType = ActionType.None, ReturnType = ReturnType, MethodName = Name, MethodType = MethodType }; if (ParameterTypes != null && ParameterTypes.Length > 0) { //MethodParameterCollection paramColl = new MethodParameterCollection(method); foreach (ParamDescription p in ParameterTypes) { method.MethodParameters.Add(new OrmEntityMethodParam { ParamName = p.Name, ParamType = p.ParamType }); } } return method; } else if (MethodType == Sage.Platform.Orm.Entities.MethodType.CrudEvent) { switch (EventType) { case AutoWire.EventType.BeforeUpdate: return entity.OnBeforeUpdateMethod; case AutoWire.EventType.AfterUpdate: return entity.OnAfterUpdateMethod; case AutoWire.EventType.BeforeInsert: return entity.OnBeforeInsertMethod; case AutoWire.EventType.AfterInsert: return entity.OnAfterInsertMethod; case AutoWire.EventType.BeforeDelete: return entity.OnBeforeDeleteMethod; default: throw new Exception("Invalid event type " + EventType + " for AutoWire method " + DeclaringType + "." + Name); } } else { throw new Exception("Unsupported method type " + MethodType + " for AutoWire method " + DeclaringType + "." + Name); } }
internal static bool IsEntityNewer(BuildType buildType, DateTime baseDate, OrmEntity entity) { if (buildType == BuildType.BuildAll) { return(true); } entity.FilePath.Refresh(); if (baseDate < entity.FilePath.LastWriteTimeUtc) { return(true); } //check all business rule methods and events IFileInfo[] methods = entity.FilePath.Directory.GetFiles(EntityModelUrlConstants.QRY_ALL_METHODS); foreach (IFileInfo methodFile in methods) { if (baseDate < methodFile.LastWriteTimeUtc) { return(true); } } if (IsNewer(entity.ParentEntities, baseDate)) { return(true); } if (IsNewer(entity.ChildEntities, baseDate)) { return(true); } if (IsNewer(entity.ExtensionEntities, baseDate)) { return(true); } return(false); }
/// <summary> /// Any method that is on the entity and is NOT in the methodsToCreate should be removed /// (this also considers the step type, eg, if the method is specified as Post, and the current one is a Pre, it will be removed) /// Any method that is on the entity is IS in the methodsToCreate should be removed from methodsToCreate. /// </summary> /// <param name="entity"></param> /// <returns>true if entity was modified as a result</returns> private static bool CleanAutowireMethods(OrmEntity entity, List <MethodDescription> methodsToCreate) { List <OrmEntityMethod> methodsToRemove = new List <OrmEntityMethod>(); bool modified = false; foreach (OrmEntityMethod method in entity.Methods.Union(new OrmEntityMethod[] { entity.OnAfterInsertMethod, entity.OnAfterDeleteMethod, entity.OnBeforeDeleteMethod, entity.OnBeforeInsertMethod, entity.OnBeforeUpdateMethod, entity.OnAfterUpdateMethod })) { if (method == null) { // happens for the "event" methods - some of them are null continue; } modified = CleanAutowireMethodsTarget(TargetStepType.Primary, method.MethodTargets, methodsToCreate) || modified; modified = CleanAutowireMethodsTarget(TargetStepType.PreExecute, method.PreExecuteTargets, methodsToCreate) || modified; modified = CleanAutowireMethodsTarget(TargetStepType.PostExecute, method.PostExecuteTargets, methodsToCreate) || modified; modified = CleanAutowireMethodsTarget(TargetStepType.PostFlush, method.PostFlushTargets, methodsToCreate) || modified; if (method.AllTargets.Count() == 0) { methodsToRemove.Add(method); } } foreach (OrmEntityMethod method in methodsToRemove) { if (entity.Methods.Contains(method)) { modified = true; method.Delete(); entity.Methods.Remove(method); } } return(modified); }
/// <summary> /// Any method that is on the entity and is NOT in the methodsToCreate should be removed /// (this also considers the step type, eg, if the method is specified as Post, and the current one is a Pre, it will be removed) /// Any method that is on the entity is IS in the methodsToCreate should be removed from methodsToCreate. /// </summary> /// <param name="entity"></param> /// <returns>true if entity was modified as a result</returns> private static bool CleanAutowireMethods(OrmEntity entity, List<MethodDescription> methodsToCreate) { List<OrmEntityMethod> methodsToRemove = new List<OrmEntityMethod>(); bool modified = false; foreach (OrmEntityMethod method in entity.Methods.Union(new OrmEntityMethod[] { entity.OnAfterInsertMethod, entity.OnAfterDeleteMethod, entity.OnBeforeDeleteMethod, entity.OnBeforeInsertMethod, entity.OnBeforeUpdateMethod, entity.OnAfterUpdateMethod })) { if (method == null) // happens for the "event" methods - some of them are null continue; modified = CleanAutowireMethodsTarget(TargetStepType.Primary, method.MethodTargets, methodsToCreate) || modified; modified = CleanAutowireMethodsTarget(TargetStepType.PreExecute, method.PreExecuteTargets, methodsToCreate) || modified; modified = CleanAutowireMethodsTarget(TargetStepType.PostExecute, method.PostExecuteTargets, methodsToCreate) || modified; modified = CleanAutowireMethodsTarget(TargetStepType.PostFlush, method.PostFlushTargets, methodsToCreate) || modified; if (method.AllTargets.Count() == 0) methodsToRemove.Add(method); } foreach (OrmEntityMethod method in methodsToRemove) { if (entity.Methods.Contains(method)) { modified = true; method.Delete(); entity.Methods.Remove(method); } } return modified; }
protected override void GenerateInternal(OperationStatus op, BuildType buildType) { if (OrmPackages.Length == 0) { return; } EnsureLibraries(); IFileInfo projectInfoPath = FileSystem.GetFileInfo(Path.Combine(FullProjectDirectory, "project.info.xml")); ProjectInfo local = ProjectInfo.Load(projectInfoPath); if (local == null || local.InstanceId != Project.InstanceId) { if (buildType == BuildType.Build) { Logging.BuildLog.Info("Full build required"); } buildType = BuildType.BuildAll; local = new ProjectInfo { InstanceId = Project.InstanceId }; if (projectInfoPath.Directory.Exists) { foreach (var file in projectInfoPath.Directory.GetFiles()) { file.Delete(); } } } CopyEntityInterfacesAssembly(); string path = FullProjectDirectory; var generatorList = new List <BaseEntityGenerator>(); // generate entities BaseEntityGenerator baseGen = new SDataClientEntityCodeGenerator(); baseGen.Initialize(WorkingDirectoryPath); generatorList.Add(baseGen); // Ensure all paths are created foreach (var gen in generatorList) { string relPath = Path.Combine(path, gen.RelativePath); if (!Directory.Exists(relPath)) { Directory.CreateDirectory(relPath); } } var model = (OrmModel)OrmPackages[0].Model; var engine = new Engine { DefaultToolsVersion = "3.5" }; bool atLeastOneFileWasGenerated = false; var buildItemFiles = new List <BuildItemFileInfo>(); foreach (var entity in OrmEntity.GetAll(model.Project).Where(item => item.Generate && item.GenerateSDataFeed)) { if (!op.CanContinue) { return; } foreach (var generator in generatorList) { string fullPath = Path.Combine(Path.Combine(path, generator.RelativePath), generator.FormatFileName(entity.Name)); var fi = new FileInfo(fullPath); if (BuildHelper.IsEntityNewer(buildType, fi.LastWriteTimeUtc, entity)) { using (var writer = new StreamWriter(fullPath)) { generator.Generate(entity, writer); } atLeastOneFileWasGenerated = true; } buildItemFiles.Add(new BuildItemFileInfo(generator, fullPath)); } } if (atLeastOneFileWasGenerated) { BuildProject(buildItemFiles, engine); } if (op.CanContinue) { local.Save(projectInfoPath); } }
private string GenerateReferencePropertyName(OrmEntity parentEntity, OrmEntity childEntity, OrmEntityProperty childProperty) { string propertyName = childProperty.PropertyName; if (propertyName.EndsWith("ID", StringComparison.InvariantCultureIgnoreCase)) { propertyName = propertyName.Substring(0, propertyName.Length - 2).Trim(); } else if (propertyName.EndsWith("CODE", StringComparison.InvariantCultureIgnoreCase)) { propertyName = propertyName.Substring(0, propertyName.Length - 4).Trim(); } else { propertyName = parentEntity.Name; } if (StringUtils.CaseInsensitiveEquals(propertyName, parentEntity.Name)) { propertyName = parentEntity.Name; } return _entityNameCreator.CreateName(childEntity, typeof (OrmEntityProperty), propertyName); }
private string GenerateCollectionPropertyName(OrmEntity parentEntity, OrmEntity childEntity) { string baseName = childEntity.Name; char lastChar = baseName[baseName.Length - 1]; if (lastChar == 'y') { baseName = baseName.Substring(0, baseName.Length - 1) + "ies"; } else if (lastChar != 's') { baseName += 's'; } return _entityNameCreator.CreateName(parentEntity, typeof (OrmEntityProperty), baseName); }
private RelationshipInfo CreateRelationship(DataPathJoin join, OrmEntity leftEntity, OrmEntity rightEntity, bool isRightPK) { string targetField = join.FromField; if (targetField.StartsWith("@")) { targetField = targetField.Substring(1); } OrmFieldProperty leftProperty = leftEntity.Properties.GetFieldPropertyByFieldName(targetField); if (leftProperty == null) { LogError(leftEntity, "Property based on field '{0}' not found on entity based on table '{1}'", join.FromField, leftEntity.TableName); return null; } targetField = join.ToField; if (targetField.StartsWith("@")) { targetField = targetField.Substring(1); } OrmFieldProperty rightProperty = rightEntity.Properties.GetFieldPropertyByFieldName(targetField); if (rightProperty == null) { LogError(rightEntity, "Property based on field '{0}' not found on entity based on table '{1}'", join.ToField, rightEntity.TableName); return null; } OrmRelationship ormRelationship = CollectionUtils.Find( _ormModel.Relationships, delegate(OrmRelationship item) { if (item.Columns.Count > 0) { OrmRelationshipColumn column = item.Columns[0]; return ((item.ParentEntity == leftEntity && item.ChildEntity == rightEntity && column.ParentProperty == leftProperty && column.ChildProperty == rightProperty && (item.Cardinality == OrmRelationship.ManyToOne) == isRightPK && item.ParentProperty.Include) || (item.ParentEntity == rightEntity && item.ChildEntity == leftEntity && column.ParentProperty == rightProperty && column.ChildProperty == leftProperty && (item.Cardinality == OrmRelationship.OneToMany) == isRightPK && item.ChildProperty.Include)); } return false; }); bool isInverted; if (ormRelationship == null) { bool isLeftDynamic = leftEntity.Package.GetGenerateAssembly(); if (!isLeftDynamic) { LogError("Cannot create the necessary relationship property for '{0}' join", join); return null; } string cardinality; string parentPropertyName; if (isRightPK) { cardinality = OrmRelationship.ManyToOne; parentPropertyName = GenerateReferencePropertyName(rightEntity, leftEntity, leftProperty); } else { cardinality = OrmRelationship.OneToMany; parentPropertyName = GenerateCollectionPropertyName(leftEntity, rightEntity); } ormRelationship = new OrmRelationship( leftEntity, rightEntity, cardinality, leftProperty, rightProperty, CascadeOption.SaveUpdate); ormRelationship.ParentProperty.PropertyName = parentPropertyName; leftEntity.ChildEntities.Add(ormRelationship); rightEntity.ParentEntities.Add(ormRelationship); ormRelationship.ChildProperty.Include = false; isInverted = false; } else { isInverted = (ormRelationship.ParentEntity == rightEntity); } return new RelationshipInfo(ormRelationship, isInverted); }
private RelationshipInfo CreateExtentedEntity(OrmEntity parentEntity, OrmEntity childEntity, bool isInverted) { if (childEntity.ExtendedEntity != null && childEntity.ExtendedEntity != parentEntity) { LogError(childEntity, "Entity '{0}' already extends entity '{1}'", childEntity, childEntity.ExtendedEntity); return null; } Debug.Assert(parentEntity != childEntity); object dummy = parentEntity.ExtensionEntities; childEntity.ExtendedEntity = parentEntity; childEntity.IsExtension = true; return new RelationshipInfo(parentEntity, childEntity, isInverted); }
private RelationshipInfo CreateExtentedEntity(DataPathJoin join, OrmEntity leftEntity, OrmEntity rightEntity, string leftKeyField, string rightKeyField) { if (leftEntity.ExtendedEntity == rightEntity) { return new RelationshipInfo(rightEntity, leftEntity, true); } else if (rightEntity.ExtendedEntity == leftEntity) { return new RelationshipInfo(leftEntity, rightEntity, false); } else { int leftSimilarity = MeasureSimilarity(join.FromTable, leftKeyField); int rightSimilarity = MeasureSimilarity(join.ToTable, rightKeyField); if (leftSimilarity == rightSimilarity) { LogError("Unable to establish owning table in join '{0}'", join); return null; } RelationshipInfo relationship = (rightSimilarity > leftSimilarity ? CreateExtentedEntity(rightEntity, leftEntity, true) : CreateExtentedEntity(leftEntity, rightEntity, false)); leftEntity.Validate(); leftEntity.Save(); rightEntity.Validate(); rightEntity.Save(); return relationship; } }