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