public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (DecimalPropertyInfo)conceptInfo; if (SimplePropertyMappingGenerator.IsSupported(info)) codeBuilder.InsertCode(@"precision=""28"" scale=""10"" ", SimplePropertyMappingGenerator.AttributesTag, info); }
public DslParser(IDslSource dslSource, IConceptInfo[] conceptInfoPlugins, ILogProvider logProvider) { _dslSource = dslSource; _conceptInfoPlugins = conceptInfoPlugins; _performanceLogger = logProvider.GetLogger("Performance"); _logger = logProvider.GetLogger("DslParser"); }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (FilterByInfo)conceptInfo; if (DataStructureCodeGenerator.IsTypeSupported(info.Source)) codeBuilder.InsertCode(CodeSnippet(info), DataStructureCodeGenerator.FilterTypesTag, info.Source); }
public void InitializeNonparsableProperties(out IEnumerable<IConceptInfo> createdConcepts) { if (!(Property.DataStructure is EntityInfo)) throw new DslSyntaxException(this, "History concept may only be used on entity or its property."); Dependency_EntityHistory = new EntityHistoryInfo { Entity = (EntityInfo)this.Property.DataStructure }; createdConcepts = new IConceptInfo[] { Dependency_EntityHistory }; }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (AutoCodePropertyInfo)conceptInfo; if (info.Property is ShortStringPropertyInfo || info.Property is LongStringPropertyInfo) _defaultAttribute.InsertOrOverrideAttribute(codeBuilder, info.Property, @"""+"""); }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (KeepSynchronizedInfo)conceptInfo; codeBuilder.InsertCode(FilterSaveFunction(info), RepositoryHelper.RepositoryMembers, info.EntityComputedFrom.Target); codeBuilder.InsertCode(SnippetDefaultFilterSaveOnRecompute(info), EntityComputedFromCodeGenerator.OverrideDefaultFiltersTag, info.EntityComputedFrom); }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { ReferencePropertyInfo info = (ReferencePropertyInfo)conceptInfo; PropertyHelper.GenerateCodeForType(info, codeBuilder, info.Referenced.Module.Name + "." + info.Referenced.Name, false); var referenceGuid = new PropertyInfo { DataStructure = info.DataStructure, Name = info.Name + "ID" }; codeBuilder.InsertCode(ReferenceIDSnippet(info, referenceGuid), DataStructureCodeGenerator.BodyTag, info.DataStructure); codeBuilder.InsertCode("[DataMember]", PropertyHelper.AttributeTag, referenceGuid); if (info.DataStructure is IWritableOrmDataStructure) { codeBuilder.InsertCode( string.Format(CultureInfo.InvariantCulture, @" foreach(var item in insertedNew) if(item.{0}ID != null) item.{0} = _executionContext.NHibernateSession.Load<{1}.{2}>(item.{0}ID); foreach(var item in updatedNew) if(item.{0}ID != null) item.{0} = _executionContext.NHibernateSession.Load<{1}.{2}>(item.{0}ID); foreach(var item in deletedIds) if(item.{0}ID != null) item.{0} = _executionContext.NHibernateSession.Load<{1}.{2}>(item.{0}ID); ", info.Name, info.Referenced.Module.Name, info.Referenced.Name), WritableOrmDataStructureCodeGenerator.InitializationTag.Evaluate(info.DataStructure)); } }
public string RemoveDatabaseStructure(IConceptInfo conceptInfo) { var info = (BoolPropertyInfo)conceptInfo; if (info.DataStructure is EntityInfo) return PropertyDatabaseDefinition.RemoveColumn(info, SqlUtility.Identifier(info.Name)); return ""; }
public string RemoveDatabaseStructure(IConceptInfo conceptInfo) { var info = (SqlQueryableInfo)conceptInfo; return Sql.Format("SqlQueryableDatabaseDefinition_Remove", SqlUtility.Identifier(info.Module.Name), SqlUtility.Identifier(info.Name)); }
public void InitializeNonparsableProperties(out IEnumerable<IConceptInfo> createdConcepts) { if (!(Property.DataStructure is EntityInfo)) throw new DslSyntaxException(this, "AutoCode concept may only be used on properties of entity."); Dependency_TriggerInfo = new AutoCodeTriggerInfo { Entity = (EntityInfo)this.Property.DataStructure }; createdConcepts = new IConceptInfo[] { Dependency_TriggerInfo }; }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { ReferencePropertyInfo info = (ReferencePropertyInfo)conceptInfo; if (DataStructureCodeGenerator.IsTypeSupported(info.DataStructure)) { var properties = GetReferenceProperties(_dslModel.Concepts, info); string lookupField = ""; var lookupColumns = new List<string>(); foreach (var prop in properties) { lookupField = prop.Name; lookupColumns.Add("\"" + prop.Name + "\""); } string lookupEntity = info.Referenced.Name; //string dodatniAtribut = string.Format(ReferenceFormat, _dslModel.Concepts.Count(), lookupEntity, String.Join(", ", lookupColumns)); string dodatniAtribut = string.Format(ReferenceFormat, lookupField, lookupEntity, String.Join(", " , lookupColumns)); MvcPropertyHelper.GenerateCodeForType(_dslModel, info, codeBuilder, "Guid?", "ID", dodatniAtribut); } }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (DenyUserEditInfo)conceptInfo; codeBuilder.InsertCode(CheckChangesOnInsertSnippet(info), WritableOrmDataStructureCodeGenerator.ArgumentValidationTag, info.Property.DataStructure); codeBuilder.InsertCode(CheckChangesOnUpdateSnippet(info), WritableOrmDataStructureCodeGenerator.OldDataLoadedTag, info.Property.DataStructure); codeBuilder.AddReferencesFromDependency(typeof(UserException)); }
public static IEnumerable<IConceptInfo> GenerateDependencies(IConceptInfo dependent, IEnumerable<IConceptInfo> existingConcepts, string sqlScript) { HashSet<string> sqlObjects; if (!SqlObjectsCache.TryGetValue(sqlScript, out sqlObjects)) { sqlObjects = new HashSet<string>(ExtractPossibleObjects(sqlScript)); SqlObjectsCache.Add(sqlScript, sqlObjects); } var newConcepts = new List<IConceptInfo>(); foreach (var conceptInfo in existingConcepts) if (conceptInfo != dependent) { var conceptType = conceptInfo.GetType(); if (typeof(DataStructureInfo).IsAssignableFrom(conceptType)) { if (sqlObjects.Contains(conceptInfo.GetKeyProperties())) // Currently, GetKeyProperties is not cached, so checking Contains after IsAssignableFrom improves execution speed. newConcepts.Add(new SqlDependsOnDataStructureInfo { Dependent = dependent, DependsOn = (DataStructureInfo)conceptInfo }); } else if (typeof(SqlViewInfo).IsAssignableFrom(conceptType)) { if (sqlObjects.Contains(conceptInfo.GetKeyProperties())) newConcepts.Add(new SqlDependsOnSqlViewInfo { Dependent = dependent, DependsOn = (SqlViewInfo)conceptInfo }); } else if (typeof(SqlFunctionInfo).IsAssignableFrom(conceptType)) { if (sqlObjects.Contains(conceptInfo.GetKeyProperties())) newConcepts.Add(new SqlDependsOnSqlFunctionInfo { Dependent = dependent, DependsOn = (SqlFunctionInfo)conceptInfo }); } } return newConcepts; }
public static IEnumerable<IConceptInfo> GenerateDependenciesToObject(IConceptInfo dependent, IEnumerable<IConceptInfo> existingConcepts, string sqlObjectName) { var newConcepts = new List<IConceptInfo>(); sqlObjectName = sqlObjectName.Trim(); bool function = sqlObjectName.Contains('('); if (function) sqlObjectName = sqlObjectName.Substring(0, sqlObjectName.IndexOf('(')); var nameParts = sqlObjectName.Split('.'); if (nameParts.Length != 2) return newConcepts; if (function) { newConcepts.AddRange(existingConcepts.OfType<SqlFunctionInfo>() .Where(ci => ci.Module.Name == nameParts[0] && ci.Name == nameParts[1] && ci != dependent) .Select(ci => new SqlDependsOnSqlFunctionInfo { Dependent = dependent, DependsOn = ci })); } else { newConcepts.AddRange(existingConcepts.OfType<DataStructureInfo>() .Where(ci => ci.Module.Name == nameParts[0] && ci.Name == nameParts[1] && ci != dependent) .Select(ci => new SqlDependsOnDataStructureInfo { Dependent = dependent, DependsOn = ci })); newConcepts.AddRange(existingConcepts.OfType<SqlViewInfo>() .Where(ci => ci.Module.Name == nameParts[0] && ci.Name == nameParts[1] && ci != dependent) .Select(ci => new SqlDependsOnSqlViewInfo { Dependent = dependent, DependsOn = ci })); } return newConcepts; }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (PropertyInfo)conceptInfo; if ((info is GuidPropertyInfo || info is IntegerPropertyInfo) && info.Name.EndsWith("ID")) _renderModeAttribute.InsertOrOverrideAttribute(codeBuilder, info, @"Rhetos.Mvc.RenderMode.EditModeOnly"); }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (PropertyComputedFromInfo)conceptInfo; codeBuilder.InsertCode(CompareValuePropertySnippet(info), EntityComputedFromCodeGenerator.CompareValuePropertyTag, info.Dependency_EntityComputedFrom); codeBuilder.InsertCode(ClonePropertySnippet(info), EntityComputedFromCodeGenerator.ClonePropertyTag, info.Dependency_EntityComputedFrom); codeBuilder.InsertCode(AssignPropertySnippet(info), EntityComputedFromCodeGenerator.AssignPropertyTag, info.Dependency_EntityComputedFrom); }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (WriteInfo)conceptInfo; codeBuilder.InsertCode("IWritableRepository<" + info.DataStructure.Module.Name + "." + info.DataStructure.Name + ">", RepositoryHelper.RepositoryInterfaces, info.DataStructure); codeBuilder.InsertCode(MemberFunctionsSnippet(info), RepositoryHelper.RepositoryMembers, info.DataStructure); }
public void ExtendDatabaseStructure(IConceptInfo conceptInfo, ICodeBuilder codeBuilder, out IEnumerable<Tuple<IConceptInfo, IConceptInfo>> createdDependencies) { var info = (PolymorphicPropertyInfo)conceptInfo; var propertyColumnNames = _conceptMetadata.Get(info.Property, PropertyDatabaseDefinition.ColumnNamesMetadata); var propertyColumnTypes = _conceptMetadata.Get(info.Property, PropertyDatabaseDefinition.ColumnTypesMetadata); foreach (var column in propertyColumnNames.Zip(propertyColumnTypes, (name, type) => new { name, type })) { string columnImplementationsSelector = info.IsImplementable() ? ", " + column.name : ", " + column.name + " = NULL"; codeBuilder.InsertCode( columnImplementationsSelector, PolymorphicUnionViewInfo.PolymorphicPropertyNameTag, info.Dependency_PolymorphicUnionView); string columnInitialization = string.Format(",\r\n {0} = CONVERT({1}, NULL)", column.name, column.type); codeBuilder.InsertCode( columnInitialization, PolymorphicUnionViewInfo.PolymorphicPropertyInitializationTag, info.Dependency_PolymorphicUnionView); } createdDependencies = null; }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (InvalidDataMarkProperty2Info)conceptInfo; string extendSystemMessage = @"+"",Property:" + info.MarkProperty.Name + @""""; codeBuilder.InsertCode(extendSystemMessage, InvalidDataCodeGenerator.SystemMessageAppendTag, info.InvalidData); }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = ((ReferenceCascadeDeleteInfo)conceptInfo); if(info.Reference.Referenced is IWritableOrmDataStructure) codeBuilder.InsertCode(CodeSnippetDeleteChildren(info), WritableOrmDataStructureCodeGenerator.OldDataLoadedTag, info.Reference.Referenced); }
public static IEnumerable<IConceptInfo> GenerateDependencies(IConceptInfo dependent, IDslModel existingConcepts, string sqlScript) { SortedSet<string> sqlObjectsInScript; if (!SqlObjectsCache.TryGetValue(sqlScript, out sqlObjectsInScript)) { sqlObjectsInScript = new SortedSet<string>(ExtractPossibleObjects(sqlScript), StringComparer.InvariantCultureIgnoreCase); SqlObjectsCache.Add(sqlScript, sqlObjectsInScript); } var newConcepts = new List<IConceptInfo>(); var conceptsBySqlName = existingConcepts.GetIndex<SqlObjectsIndex>().ConceptsBySqlName; foreach (var sqlObjectInScript in sqlObjectsInScript) foreach (var conceptInfo in conceptsBySqlName.Get(sqlObjectInScript)) if (conceptInfo != dependent) { if (conceptInfo is DataStructureInfo) newConcepts.Add(new SqlDependsOnDataStructureInfo { Dependent = dependent, DependsOn = (DataStructureInfo)conceptInfo }); else if (conceptInfo is SqlViewInfo) newConcepts.Add(new SqlDependsOnSqlViewInfo { Dependent = dependent, DependsOn = (SqlViewInfo)conceptInfo }); else if (conceptInfo is SqlFunctionInfo) newConcepts.Add(new SqlDependsOnSqlFunctionInfo { Dependent = dependent, DependsOn = (SqlFunctionInfo)conceptInfo }); else throw new DslSyntaxException(dependent, "Internal error: Unexpected SQL concept type: " + conceptInfo.GetUserDescription() + "."); } return newConcepts; }
public string CreateDatabaseStructure(IConceptInfo conceptInfo) { var info = (DateTimePropertyInfo)conceptInfo; if (info.DataStructure is EntityInfo) return PropertyDatabaseDefinition.AddColumn(info, SqlUtility.Identifier(info.Name), Sql.Get("DateTimePropertyDatabaseDefinition_DataType")); return ""; }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (ComputationUseExecutionContextInfo)conceptInfo; codeBuilder.InsertCode(", Common.ExecutionContext", DataStructureUtility.ComputationAdditionalParametersTypeTag, info.Computation); codeBuilder.InsertCode(", _executionContext", DataStructureUtility.ComputationAdditionalParametersArgumentTag, info.Computation); }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (DataStructureInfo)conceptInfo; var orm = info as IOrmDataStructure; if (orm != null) { codeBuilder.InsertCode(SnippetEntityClassMembers(info), DataStructureCodeGenerator.BodyTag, info); DataStructureCodeGenerator.AddInterfaceAndReference(codeBuilder, string.Format("System.IEquatable<{0}>", info.Name), typeof(System.IEquatable<>), info); RepositoryHelper.GenerateRepository(info, codeBuilder); RepositoryHelper.GenerateQueryableRepositoryFunctions(info, codeBuilder, QuerySnippet(info)); codeBuilder.InsertCode(SnippetQueryableFilterById(info), RepositoryHelper.RepositoryMembers, info); PropertyInfo idProperty = new PropertyInfo { DataStructure = info, Name = "ID" }; PropertyHelper.GenerateCodeForType(idProperty, codeBuilder, "Guid"); DataStructureCodeGenerator.AddInterfaceAndReference(codeBuilder, typeof(IEntity), info); codeBuilder.InsertCode( string.Format("public System.Data.Entity.DbSet<Common.Queryable.{0}_{1}> {0}_{1} {{ get; set; }}\r\n ", info.Module.Name, info.Name), DomInitializationCodeGenerator.EntityFrameworkContextMembersTag); codeBuilder.InsertCode( string.Format("modelBuilder.Ignore<global::{0}.{1}>();\r\n " + "modelBuilder.Entity<Common.Queryable.{0}_{1}>().Map(m => {{ m.MapInheritedProperties(); m.ToTable(\"{3}\", \"{2}\"); }});\r\n ", info.Module.Name, info.Name, orm.GetOrmSchema(), orm.GetOrmDatabaseObject()), DomInitializationCodeGenerator.EntityFrameworkOnModelCreatingTag); } }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (ReportDataInfo)conceptInfo; RepositoryHelper.GenerateRepository(info, codeBuilder); codeBuilder.InsertCode(RepositoryFunctionsSnippet(info), RepositoryHelper.RepositoryMembers, info); }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (DataStructureInfo)conceptInfo; if (info.Module.Name == "Common" && info.Name == "FilterId") codeBuilder.InsertCode(snippet, RepositoryHelper.RepositoryMembers, info); }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (PropertyInfo)conceptInfo; if (info.Name.Equals("Active", StringComparison.InvariantCultureIgnoreCase)) _defaultAttribute.InsertOrOverrideAttribute(codeBuilder, info, @"true"); }
public void ExtendDatabaseStructure(IConceptInfo conceptInfo, ICodeBuilder codeBuilder, out System.Collections.Generic.IEnumerable<Tuple<IConceptInfo, IConceptInfo>> createdDependencies) { var info = (SqlNotNullInfo)conceptInfo; var sql = new StringBuilder(); if (_conceptMetadata.Contains(info.Property, PropertyDatabaseDefinition.ColumnTypesMetadata)) { var columnNames = _conceptMetadata.Get(info.Property, PropertyDatabaseDefinition.ColumnNamesMetadata); var columnTypes = _conceptMetadata.Get(info.Property, PropertyDatabaseDefinition.ColumnTypesMetadata); var columns = columnNames.Zip(columnTypes, (name, type) => new { name, type }); foreach (var column in columns) sql.AppendLine(Sql.Format("SqlNotNull_Create", SqlUtility.Identifier(info.Property.DataStructure.Module.Name), SqlUtility.Identifier(info.Property.DataStructure.Name), column.name, column.type, info.InitialValueSqlExpression, SqlUtility.ScriptSplitterTag).Trim()); } var sqlSnippet = sql.ToString().Trim() + "\r\n"; if (!string.IsNullOrWhiteSpace(sqlSnippet)) codeBuilder.InsertCode(sqlSnippet, PropertyDatabaseDefinition.AfterCreateTag, info.Property); createdDependencies = null; }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (DateTimePropertyInfo)conceptInfo; if (SimplePropertyMappingGenerator.IsSupported(info)) codeBuilder.InsertCode(@"type=""timestamp"" ", SimplePropertyMappingGenerator.AttributesTag, info); }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (InvalidDataInfo)conceptInfo; // Using nonstandard naming of variables to avoid name clashes with injected code. string getErrorMessageMethod = @"public IEnumerable<InvalidDataMessage> " + info.GetErrorMessageMethodName() + @"(IEnumerable<Guid> invalidData_Ids) { const string invalidData_Description = " + CsUtility.QuotedString(info.ErrorMessage) + @"; " + OverrideUserMessagesTag.Evaluate(info) + @" return invalidData_Ids.Select(id => new InvalidDataMessage { ID = id, Message = invalidData_Description }); } "; codeBuilder.InsertCode(getErrorMessageMethod, RepositoryHelper.RepositoryMembers, info.Source); codeBuilder.AddReferencesFromDependency(typeof(InvalidDataMessage)); string dataStructure = info.Source.Module.Name + "." + info.Source.Name; string systemMessage = @"""DataStructure:" + dataStructure + @",ID:"" + invalidItemId.ToString()" + SystemMessageAppendTag.Evaluate(info); string validationSnippet = @"if (insertedNew.Count() > 0 || updatedNew.Count() > 0) { Guid[] changedItemsId = inserted.Concat(updated).Select(item => item.ID).ToArray(); Guid invalidItemId = this.Filter(this.Query(changedItemsId), new " + info.FilterType + @"()) .Select(item => item.ID).FirstOrDefault(); if (invalidItemId != default(Guid)) { var userMessage = " + info.GetErrorMessageMethodName() + @"(new[] { invalidItemId }).Single(); string systemMessage = " + systemMessage + @"; throw new Rhetos.UserException(userMessage.Message, userMessage.MessageParameters, systemMessage, null); } } "; codeBuilder.InsertCode(validationSnippet, WritableOrmDataStructureCodeGenerator.OnSaveTag2, info.Source); codeBuilder.AddReferencesFromDependency(typeof(UserException)); }
public static void CheckIfPropertyBelongsToDataStructure(PropertyInfo property, DataStructureInfo dataStructure, IConceptInfo errorContext) { if (property.DataStructure != dataStructure) { throw new DslSyntaxException(errorContext, $"Property {property.FullName} is not in data structure {dataStructure.FullName}."); } }
public string CreateDatabaseStructure(IConceptInfo conceptInfo) { return("create " + ((BaseCi)conceptInfo).Name); }
/// <summary> /// Returns all entities that a given data structure is constructed from. /// If the given data structure depends is an entity, it will be the only item in the result. /// </summary> public static List <DataStructureInfo> GetDependsOnWriteableDataStructure(DataStructureInfo dataStructure, IDslModel allConcepts, IConceptInfo errorContext) { var dependencies = new List <DataStructureInfo>(); GetDependsOnWriteableDataStructure(dataStructure, dependencies, allConcepts, errorContext, new HashSet <string>()); return(dependencies); }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { InvalidDataInfo info = (InvalidDataInfo)conceptInfo; PropertyCodeGeneratorHelper.GenerateCodeForInvalidData(info, codeBuilder); }
private void AddPolymorphicImplementations(List <Tuple <DataStructureInfo, string> > computationDependencies, PolymorphicInfo polymorphic, IDslModel existingConcepts, IConceptInfo errorContext) { var implementations = existingConcepts.FindByReference <IsSubtypeOfInfo>(imp => imp.Supertype, polymorphic); var unsupported = implementations.Where(imp => !(imp.Subtype is IWritableOrmDataStructure)).FirstOrDefault(); if (unsupported != null) { throw new DslSyntaxException(errorContext, $"The referenced '{polymorphic.GetUserDescription()}' is not supported" + $" because it contains a non-writable implementation '{unsupported.Subtype.GetUserDescription()}'." + $" Please use ChangesOnChangedItems instead, to manually set the computation's dependencies."); } computationDependencies.AddRange(implementations.Select(imp => Tuple.Create(imp.Subtype, IsSubtypeOfMacro.GetComputeHashIdSelector(imp)))); }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (ArgumentValidationInfo)conceptInfo; codeBuilder.InsertCode(GetSnippet(info), WritableOrmDataStructureCodeGenerator.ArgumentValidationTag, info.SaveMethod.Entity); }
public DslSyntaxException(IConceptInfo concept, string additionalMessage, Exception inner) : base(concept.GetUserDescription() + ": " + additionalMessage, inner) { }
private static void GetDependsOnWriteableDataStructure(DataStructureInfo dataStructure, List <DataStructureInfo> dependencies, IDslModel allConcepts, IConceptInfo errorContext, HashSet <string> done) { var conceptKey = dataStructure.GetKey(); if (done.Contains(conceptKey)) { return; } done.Add(conceptKey); if (dataStructure is EntityInfo) { dependencies.Add(dataStructure); } else if (dataStructure is SqlQueryableInfo) { var deps = allConcepts.FindByReference <SqlDependsOnDataStructureInfo>(dep => dep.Dependent, dataStructure).ToArray(); foreach (var dep in deps) { GetDependsOnWriteableDataStructure(dep.DependsOn, dependencies, allConcepts, errorContext, done); } } else { throw new DslSyntaxException(errorContext.GetKeywordOrTypeName() + " is not supported on dependency type '" + dataStructure.GetKeywordOrTypeName() + "'. " + errorContext.GetUserDescription() + " depends on " + dataStructure.GetUserDescription() + "."); } }
public static ConceptMember[] Get(IConceptInfo conceptInfo) { return(Get(conceptInfo.GetType(), new Lazy <IConceptInfo>(() => conceptInfo))); }
protected void UpdateContextForNextConcept(TokenReader tokenReader, Stack <IConceptInfo> context, IConceptInfo conceptInfo) { if (tokenReader.TryRead("{")) { context.Push(conceptInfo); } else if (!tokenReader.TryRead(";")) { var sb = new StringBuilder(); sb.Append(ReportErrorContext(conceptInfo, tokenReader)); sb.AppendFormat("Expected \";\" or \"{{\"."); throw new DslSyntaxException(sb.ToString()); } while (tokenReader.TryRead("}")) { if (context.Count == 0) { throw new DslSyntaxException(tokenReader.ReportPosition() + "\r\nUnexpected \"}\". "); } context.Pop(); } }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (PersistedDataStructureInfo)conceptInfo; codeBuilder.InsertCode(CodeSnippet(info), RepositoryHelper.RepositoryMembers, info); }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (BeforeActionInfo)conceptInfo; codeBuilder.InsertCode("// " + info.RuleName + ":\r\n " + info.CodeSnippet.Trim() + "\r\n ", ActionCodeGenerator.BeforeActionTag, info.Action); }
public static ConceptMember[] Get(IConceptInfo conceptInfo) { return(Get(conceptInfo.GetType(), conceptInfo)); }
private static ConceptMember[] Get(Type conceptInfoType, IConceptInfo instance) { ConceptMember[] cached; if (_cache.TryGetValue(conceptInfoType, out cached)) { return(cached); } HashSet <string> nonParsableMembers = null; if (typeof(IAlternativeInitializationConcept).IsAssignableFrom(conceptInfoType)) { var alternativeInitializationConcept = instance != null ? (IAlternativeInitializationConcept)instance : (IAlternativeInitializationConcept)Activator.CreateInstance(conceptInfoType); nonParsableMembers = new HashSet <string>(alternativeInitializationConcept.DeclareNonparsableProperties()); } var conceptMembers = conceptInfoType .GetProperties(BindingFlags.Instance | BindingFlags.Public) .Where(p => p.CanWrite) .Select(memberInfo => new ConceptMember(memberInfo, nonParsableMembers)) .ToArray(); if (conceptInfoType.GetFields(BindingFlags.Instance | BindingFlags.Public).Length > 0) { throw new FrameworkException( string.Format(CultureInfo.InvariantCulture, "IConceptInfo does not support public fields. Use public properties instead. Class: \"{0}\".", conceptInfoType.Name)); } Array.Sort(conceptMembers, (a, b) => { int diff = a.SortOrder1 - b.SortOrder1; if (diff != 0) { return(diff); } return(a.SortOrder2 - b.SortOrder2); }); if (!conceptMembers.Any(m => m.IsKey)) { throw new FrameworkException( string.Format(CultureInfo.InvariantCulture, "One or more members of concept-info class must have ConceptKey attribute. Class: \"{0}\".", conceptInfoType.Name)); } if (typeof(IConceptInfo).IsAssignableFrom(conceptInfoType.BaseType) && conceptInfoType.BaseType.IsClass) { string derivedKeyMember = conceptMembers.Where(m => m.IsKey && !m.IsDerived).Select(m => m.Name).FirstOrDefault(); if (derivedKeyMember != null) { throw new FrameworkException(string.Format( "Derived concept must not contain members with ConceptKey attribute. Class: {0}, member: {1}.", conceptInfoType.Name, derivedKeyMember)); } } if (nonParsableMembers != null) { string nonexistentMember = nonParsableMembers.Except(conceptMembers.Select(m => m.Name)).FirstOrDefault(); if (nonexistentMember != null) { throw new FrameworkException(string.Format( "Invalid implementation of the concept info function {0}.DeclareNonparsableProperties: it returned a property name '{1}' that does not exist.", conceptInfoType.Name, nonexistentMember)); } } _cache.Add(conceptInfoType, conceptMembers); return(conceptMembers); }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (LongStringPropertyInfo)conceptInfo; _hintAttribute.InsertOrOverrideAttribute(codeBuilder, info, @"""StringMultiline"""); }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (OnSaveUpdateInfo)conceptInfo; codeBuilder.InsertCode(GetSnippet(info), WritableOrmDataStructureCodeGenerator.OnSaveTag1, info.SaveMethod.Entity); }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { DataStructureInfo info = (DataStructureInfo)conceptInfo; codeBuilder.InsertCode(ImplementationCodeSnippet(info)); }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (MoneyPropertyInfo)conceptInfo; _formatAttribute.InsertOrOverrideAttribute(codeBuilder, info, @"DataType.Currency"); }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { codeBuilder.InsertCode("AddInterceptor(new Rhetos.Dom.DefaultConcepts.Persistence.FullTextSearchInterceptor());\r\n ", DomInitializationCodeGenerator.EntityFrameworkConfigurationTag); codeBuilder.AddReferencesFromDependency(typeof(FullTextSearchInterceptor)); }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { ReferencePropertyInfo info = (ReferencePropertyInfo)conceptInfo; var referenceGuid = new PropertyInfo { DataStructure = info.DataStructure, Name = info.Name + "ID" }; PropertyHelper.GenerateCodeForType(referenceGuid, codeBuilder, "Guid?"); if (DslUtility.IsQueryable(info.DataStructure) && DslUtility.IsQueryable(info.Referenced)) { DataStructureQueryableCodeGenerator.AddNavigationPropertyWithBackingField(codeBuilder, info.DataStructure, csPropertyName: info.Name, propertyType: "Common.Queryable." + info.Referenced.Module.Name + "_" + info.Referenced.Name, additionalSetterCode: info.Name + "ID = value != null ? (Guid?)value.ID : null;"); } if (info.DataStructure is IOrmDataStructure && info.Referenced is IOrmDataStructure) { codeBuilder.InsertCode( info.OrmMappingSnippet(), DomInitializationCodeGenerator.EntityFrameworkOnModelCreatingTag); } else if (info.DataStructure is IOrmDataStructure) { codeBuilder.InsertCode( string.Format("modelBuilder.Entity<Common.Queryable.{0}_{1}>().Ignore(t => t.{2});\r\n ", info.DataStructure.Module.Name, info.DataStructure.Name, info.Name), DomInitializationCodeGenerator.EntityFrameworkOnModelCreatingTag); } if (ReferencePropertyDbConstraintInfo.IsSupported(info) && info.DataStructure is IOrmDataStructure && info.Referenced is IOrmDataStructure) { var ormDataStructure = (IOrmDataStructure)info.DataStructure; var referencedOrmDataStructure = (IOrmDataStructure)info.Referenced; string systemMessage = "DataStructure:" + info.DataStructure + ",Property:" + info.Name + "ID,Referenced:" + info.Referenced; if (info.DataStructure is IWritableOrmDataStructure) { string onEnterInterpretSqlError = @"if (interpretedException is Rhetos.UserException && Rhetos.Utilities.MsSqlUtility.IsReferenceErrorOnInsertUpdate(interpretedException, " + CsUtility.QuotedString(referencedOrmDataStructure.GetOrmSchema() + "." + referencedOrmDataStructure.GetOrmDatabaseObject()) + @", " + CsUtility.QuotedString("ID") + @", " + CsUtility.QuotedString(ReferencePropertyConstraintDatabaseDefinition.GetConstraintName(info)) + @")) ((Rhetos.UserException)interpretedException).SystemMessage = " + CsUtility.QuotedString(systemMessage) + @"; "; codeBuilder.InsertCode(onEnterInterpretSqlError, WritableOrmDataStructureCodeGenerator.OnDatabaseErrorTag, info.DataStructure); } if (info.Referenced is IWritableOrmDataStructure) { string onDeleteInterpretSqlError = @"if (interpretedException is Rhetos.UserException && Rhetos.Utilities.MsSqlUtility.IsReferenceErrorOnDelete(interpretedException, " + CsUtility.QuotedString(ormDataStructure.GetOrmSchema() + "." + ormDataStructure.GetOrmDatabaseObject()) + @", " + CsUtility.QuotedString(info.GetSimplePropertyName()) + @", " + CsUtility.QuotedString(ReferencePropertyConstraintDatabaseDefinition.GetConstraintName(info)) + @")) ((Rhetos.UserException)interpretedException).SystemMessage = " + CsUtility.QuotedString(systemMessage) + @"; "; codeBuilder.InsertCode(onDeleteInterpretSqlError, WritableOrmDataStructureCodeGenerator.OnDatabaseErrorTag, info.Referenced); } } }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (LockItemsInfo)conceptInfo; codeBuilder.InsertCode(CheckLockedItemsSnippet(info), WritableOrmDataStructureCodeGenerator.OldDataLoadedTag, info.Source); }
public void InitializeNonparsableProperties(out IEnumerable <IConceptInfo> createdConcepts) { Path = BaseSelector + "." + BaseProperty.Name; createdConcepts = new IConceptInfo[] {}; }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { var info = (UserRequiredPropertyInfo)conceptInfo; RequiredAttribute.InsertOrOverrideAttribute(codeBuilder, info.Property, ""); }
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder) { codeBuilder.InsertCode( "internal class DontTrackHistory<T> : List<T>\r\n {\r\n }\r\n ", ModuleCodeGenerator.CommonNamespaceMembersTag); }
public string RemoveDatabaseStructure(IConceptInfo conceptInfo) { return(null); }
public string RemoveDatabaseStructure(IConceptInfo conceptInfo) { return("remove " + ((BaseCi)conceptInfo).Name); }
public string CreateDatabaseStructure(IConceptInfo conceptInfo) { return(""); }
public static IEnumerable <IConceptInfo> CopySqlDependencies(IConceptInfo from, IConceptInfo to, IDslModel existingConcepts) { var newConcepts = new List <IConceptInfo>(); newConcepts.AddRange(existingConcepts.FindByReference <SqlDependsOnDataStructureInfo>(dep => dep.Dependent, from) .Select(dep => new SqlDependsOnDataStructureInfo { Dependent = to, DependsOn = dep.DependsOn })); newConcepts.AddRange(existingConcepts.FindByReference <SqlDependsOnIDInfo>(dep => dep.Dependent, from) .Select(dep => new SqlDependsOnIDInfo { Dependent = to, DependsOn = dep.DependsOn })); newConcepts.AddRange(existingConcepts.FindByReference <SqlDependsOnModuleInfo>(dep => dep.Dependent, from) .Select(dep => new SqlDependsOnModuleInfo { Dependent = to, DependsOn = dep.DependsOn })); newConcepts.AddRange(existingConcepts.FindByReference <SqlDependsOnPropertyInfo>(dep => dep.Dependent, from) .Select(dep => new SqlDependsOnPropertyInfo { Dependent = to, DependsOn = dep.DependsOn })); newConcepts.AddRange(existingConcepts.FindByReference <SqlDependsOnSqlFunctionInfo>(dep => dep.Dependent, from) .Select(dep => new SqlDependsOnSqlFunctionInfo { Dependent = to, DependsOn = dep.DependsOn })); newConcepts.AddRange(existingConcepts.FindByReference <SqlDependsOnSqlIndexInfo>(dep => dep.Dependent, from) .Select(dep => new SqlDependsOnSqlIndexInfo { Dependent = to, DependsOn = dep.DependsOn })); newConcepts.AddRange(existingConcepts.FindByReference <SqlDependsOnSqlObjectInfo>(dep => dep.Dependent, from) .Select(dep => new SqlDependsOnSqlObjectInfo { Dependent = to, DependsOn = dep.DependsOn })); newConcepts.AddRange(existingConcepts.FindByReference <SqlDependsOnSqlViewInfo>(dep => dep.Dependent, from) .Select(dep => new SqlDependsOnSqlViewInfo { Dependent = to, DependsOn = dep.DependsOn })); return(newConcepts); }
public static void ValidatePath(DataStructureInfo source, string path, IDslModel existingConcepts, IConceptInfo errorContext) { var property = GetPropertyByPath(source, path, existingConcepts); if (property.IsError) { throw new DslSyntaxException(errorContext, "Invalid path: " + property.Error); } }
public void ExtendDatabaseStructure(IConceptInfo conceptInfo, ICodeBuilder codeBuilder, out IEnumerable <Tuple <IConceptInfo, IConceptInfo> > createdDependencies) { createdDependencies = tempConceptInfoDependencies; }