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 = (InitializationConcept)conceptInfo;
codeBuilder.InsertCode(SnippetInfrastructureKeepSynchronizedMetadata(), ModuleCodeGenerator.CommonInfrastructureMembersTag);
codeBuilder.InsertCode(SnippetRegisterInfrastructure(), ModuleCodeGenerator.CommonAutofacConfigurationMembersTag);
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
DataStructureExtendsInfo info = (DataStructureExtendsInfo)conceptInfo;
var extensionPropertyName = ExtensionPropertyName(info);
if (DslUtility.IsQueryable(info.Extension) && DslUtility.IsQueryable(info.Base))
{
DataStructureQueryableCodeGenerator.AddNavigationPropertyWithBackingField(codeBuilder, info.Extension,
csPropertyName: "Base",
propertyType: "Common.Queryable." + info.Base.Module.Name + "_" + info.Base.Name,
additionalSetterCode: "ID = value != null ? value.ID : Guid.Empty;");
DataStructureQueryableCodeGenerator.AddNavigationPropertyWithBackingField(codeBuilder, info.Base,
csPropertyName: extensionPropertyName,
propertyType: "Common.Queryable." + info.Extension.Module.Name + "_" + info.Extension.Name,
additionalSetterCode: null);
}
if (info.Extension is IOrmDataStructure && info.Base is IOrmDataStructure)
codeBuilder.InsertCode(
string.Format("modelBuilder.Entity<Common.Queryable.{0}_{1}>().HasRequired(t => t.Base).WithOptional(t => t.{2});\r\n ",
info.Extension.Module.Name, info.Extension.Name, extensionPropertyName),
DomInitializationCodeGenerator.EntityFrameworkOnModelCreatingTag);
else if (info.Extension is IOrmDataStructure)
codeBuilder.InsertCode(
string.Format("modelBuilder.Entity<Common.Queryable.{0}_{1}>().Ignore(t => t.Base);\r\n ",
info.Extension.Module.Name, info.Extension.Name),
DomInitializationCodeGenerator.EntityFrameworkOnModelCreatingTag);
else if (info.Base is IOrmDataStructure)
codeBuilder.InsertCode(
string.Format("modelBuilder.Entity<Common.Queryable.{0}_{1}>().Ignore(t => t.{2});\r\n ",
info.Base.Module.Name, info.Base.Name, extensionPropertyName),
DomInitializationCodeGenerator.EntityFrameworkOnModelCreatingTag);
}
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 = (DecimalPropertyInfo)conceptInfo;
if (SimplePropertyMappingGenerator.IsSupported(info))
codeBuilder.InsertCode(@"precision=""28"" scale=""10"" ", SimplePropertyMappingGenerator.AttributesTag, info);
}
public void ExtendDatabaseStructure(IConceptInfo conceptInfo, ICodeBuilder codeBuilder, out IEnumerable<Tuple<IConceptInfo, IConceptInfo>> createdDependencies)
{
var info = (SqlUniqueMultipleInfo)conceptInfo;
createdDependencies = null;
codeBuilder.InsertCode(Sql.Get("SqlUniqueMultipleDatabaseDefinition_ExtendOption1"), SqlIndexMultipleDatabaseDefinition.Options1Tag, info.SqlIndex);
}
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 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)
{
var info = (PropertyInfo)conceptInfo;
if (info.Name.Equals("Active", StringComparison.InvariantCultureIgnoreCase))
_defaultAttribute.InsertOrOverrideAttribute(codeBuilder, info, @"true");
}
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 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 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 = (InitializationConcept)conceptInfo;
codeBuilder.InsertCode(GenerateCommonClassesSnippet());
if (_configuration.GetBool("EntityFramework.UseDatabaseNullSemantics", false).Value == true)
codeBuilder.InsertCode("this.Configuration.UseDatabaseNullSemantics = true;\r\n ", EntityFrameworkContextInitializeTag);
// Types used in the preceding code snippet:
codeBuilder.AddReferencesFromDependency(typeof(Autofac.Module)); // Includes a reference to Autofac.dll.
codeBuilder.AddReferencesFromDependency(typeof(Rhetos.Extensibility.INamedPlugins<>));
codeBuilder.AddReferencesFromDependency(typeof(Rhetos.Utilities.IUserInfo));
codeBuilder.AddReferencesFromDependency(typeof(Rhetos.Utilities.ISqlExecuter));
codeBuilder.AddReferencesFromDependency(typeof(Rhetos.Security.IAuthorizationManager));
codeBuilder.AddReferencesFromDependency(typeof(System.ComponentModel.Composition.ExportAttribute));
codeBuilder.AddReferencesFromDependency(typeof(Rhetos.Dom.DefaultConcepts.GenericRepositories));
codeBuilder.AddReferencesFromDependency(typeof(Rhetos.Logging.ILogProvider));
codeBuilder.AddReferencesFromDependency(typeof(Rhetos.Security.IWindowsSecurity));
codeBuilder.AddReferencesFromDependency(typeof(System.Data.Entity.DbContext));
codeBuilder.AddReferencesFromDependency(typeof(System.Data.Entity.SqlServer.SqlProviderServices));
codeBuilder.AddReferencesFromDependency(typeof(System.Data.Entity.Core.EntityClient.EntityConnection));
codeBuilder.AddReferencesFromDependency(typeof(System.Data.Entity.Core.Metadata.Edm.MetadataWorkspace));
codeBuilder.AddReferencesFromDependency(typeof(System.Data.Entity.Infrastructure.IObjectContextAdapter));
codeBuilder.AddReferencesFromDependency(typeof(System.Data.Entity.Core.Objects.ObjectStateEntry));
codeBuilder.AddReferencesFromDependency(typeof(Rhetos.Persistence.IPersistenceCache));
codeBuilder.AddReferencesFromDependency(typeof(Rhetos.Persistence.IPersistenceTransaction));
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (RegisteredInterfaceImplementationInfo)conceptInfo;
var interfaceType = Type.GetType(info.InterfaceAssemblyQualifiedName);
if (interfaceType == null)
throw new DslSyntaxException(conceptInfo, "Could not find type '" + info.InterfaceAssemblyQualifiedName + "'.");
// TODO: Remove IQueryableRepository registration. IQueryableRepository should be cast from repository object in Rhetos.Dom.DefaultConcepts.GenericRepositories class.
string registerRepository = string.Format(
@"builder.RegisterType<{0}._Helper.{1}_Repository>().As<IQueryableRepository<{2}>>().InstancePerLifetimeScope();
",
info.DataStructure.Module.Name,
info.DataStructure.Name,
interfaceType.FullName);
codeBuilder.InsertCode(registerRepository, ModuleCodeGenerator.CommonAutofacConfigurationMembersTag);
string registerImplementationName = string.Format(
@"{{ typeof({0}), {1} }},
",
interfaceType.FullName,
CsUtility.QuotedString(
info.DataStructure.Module.Name
+ "." + info.DataStructure.Name));
codeBuilder.InsertCode(registerImplementationName, ModuleCodeGenerator.RegisteredInterfaceImplementationNameTag);
}
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 = ((ReferenceCascadeDeleteInfo)conceptInfo);
if(info.Reference.Referenced is IWritableOrmDataStructure)
codeBuilder.InsertCode(CodeSnippetDeleteChildren(info), WritableOrmDataStructureCodeGenerator.OldDataLoadedTag, info.Reference.Referenced);
}
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 = (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 = (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)
{
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 static void GenerateQueryableRepositoryFunctions(DataStructureInfo info, ICodeBuilder codeBuilder, string queryFunctionBody)
{
GenerateReadableRepositoryFunctions(info, codeBuilder, "return Query().ToArray();\r\n ");
codeBuilder.InsertCode(RepositoryQueryFunctionsSnippet(info, queryFunctionBody), RepositoryMembers, info);
codeBuilder.InsertCode("IQueryableRepository<" + info.Module.Name + "." + info.Name + ">", RepositoryInterfaces, info);
codeBuilder.InsertCode("IFilterRepository<IEnumerable<Guid>, " + info.Module.Name + "." + info.Name + ">", RepositoryInterfaces, info);
}
public void GenerateCode(Dsl.IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (DataStructureInfo)conceptInfo;
if (info.Module.Name == "Common" && info.Name == "Claim")
codeBuilder.InsertCode(DeactivateInsteadOfDelete, ClaimRepositoryCodeGenerator.DeactivateInsteadOfDeleteTag, info);
}
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 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 = (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 void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (RegisteredInterfaceImplementationInfo)conceptInfo;
codeBuilder.InsertCode(RegisterRepository(info), ModuleCodeGenerator.CommonAutofacConfigurationMembersTag);
codeBuilder.InsertCode(RegisterImplementationName(info), ModuleCodeGenerator.RegisteredInterfaceImplementationNameTag);
}
public void ExtendDatabaseStructure(IConceptInfo conceptInfo, ICodeBuilder codeBuilder, out IEnumerable<Tuple<IConceptInfo, IConceptInfo>> createdDependencies)
{
var info = (SubtypeExtendPolymorphicInfo)conceptInfo;
codeBuilder.InsertCode(UnionSubquerySnippet(info), PolymorphicUnionViewInfo.SubtypeQueryTag, info.PolymorphicUnionView);
createdDependencies = new[] { Tuple.Create<IConceptInfo, IConceptInfo>(info.SubtypeImplementationView, info.PolymorphicUnionView) };
}
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 = (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 GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (DateTimePropertyInfo)conceptInfo;
if (SimplePropertyMappingGenerator.IsSupported(info))
codeBuilder.InsertCode(@"type=""timestamp"" ", SimplePropertyMappingGenerator.AttributesTag, info);
}
public override void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
if (conceptInfo is RowPermissionsReadInfo info)
{
codeBuilder.InsertCode(FilterTemplates.GetHasReadRowPermissions(), CsTagsManager.Instance.Get <DataStructureInfo>(CsTagNames.AdditionalFunctions), info.Source);
}
base.GenerateCode(conceptInfo, codeBuilder);
}
public static void GenerateStorageCustomMapping(PropertyInfo info, ICodeBuilder codeBuilder, string sqlParameter)
{
if (info.DataStructure is IWritableOrmDataStructure)
{
var code = $@"new PersistenceStorageObjectParameter(""{info.Name}"", {sqlParameter}),
";
codeBuilder.InsertCode(code, WritableOrmDataStructureCodeGenerator.PersistenceStorageMapperPropertyMappingTag, info.DataStructure);
}
}
public void GenerateCode(Dsl.IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (DataStructureInfo)conceptInfo;
if (info.Module.Name == "Common" && info.Name == "Claim")
{
codeBuilder.InsertCode(DeactivateInsteadOfDelete, ClaimRepositoryCodeGenerator.DeactivateInsteadOfDeleteTag, info);
}
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (EntityComputedFromDefaultLoadFilterInfo)conceptInfo;
codeBuilder.InsertCode(
"\r\n filterLoad = filterLoad ?? new " + info.LoadFilter + "();",
EntityComputedFromCodeGenerator.OverrideDefaultFiltersTag,
info.EntityComputedFrom);
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (ReportDataInfo)conceptInfo;
codeBuilder.InsertCode(ServiceDefinitionCodeSnippet(info), InitialCodeGenerator.RhetosRestClassesTag);
codeBuilder.AddReferencesFromDependency(typeof(Rhetos.WebApiRestGenerator.Utilities.ServiceUtility));
codeBuilder.AddReferencesFromDependency(typeof(Rhetos.WebApiRestGenerator.Utilities.DownloadReportResult));
codeBuilder.AddReferencesFromDependency(typeof(Newtonsoft.Json.JsonConvert));
}
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 = (RowPermissionsInheritWriteSameMemberInfo)conceptInfo;
codeBuilder.InsertCode(
"Tuple.Create(" + CsUtility.QuotedString(info.DerivedMemberName) + ", " + CsUtility.QuotedString(info.BaseMemberName) + "), ",
RowPermissionsInheritWriteCodeGenerator.SameMembersTag,
info.InheritWrite);
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (PropertyInfo)conceptInfo;
if (info.Name.Equals("Active", StringComparison.InvariantCultureIgnoreCase))
{
_defaultAttribute.InsertOrOverrideAttribute(codeBuilder, info, @"true");
}
}
public override void GenerateCode(PropertyInfo propertyInfo, ICodeBuilder codeBuilder)
{
if (propertyInfo.DataStructure is IOrmDataStructure && IsTypeSupported(propertyInfo.GetType()))
{
codeBuilder.InsertCode("\r\n" + GetPropertyElementForConceptualModel(propertyInfo), DataStructureEdmxCodeGenerator.ConceptualModelEntityTypePropertyTag.Evaluate(propertyInfo.DataStructure));
codeBuilder.InsertCode("\r\n" + GetScalarPropertyElement(propertyInfo), DataStructureEdmxCodeGenerator.EntitySetMappingPropertyTag.Evaluate(propertyInfo.DataStructure));
codeBuilder.InsertCode("\r\n" + GetPropertyElementForStorageModel(propertyInfo), DataStructureEdmxCodeGenerator.StorageModelEntityTypePropertyTag.Evaluate(propertyInfo.DataStructure));
}
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
HardcodedEntityInfo info = (HardcodedEntityInfo)conceptInfo;
var codeSnippet =
$@"throw new Rhetos.UserException(""It is not allowed to modify hard-coded data in {{0}}."", new []{{""{conceptInfo.GetKeyProperties()}""}}, null, null);
";
codeBuilder.InsertCode(codeSnippet, WritableOrmDataStructureCodeGenerator.ArgumentValidationTag, info);
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
ReferencePropertyInfo info = (ReferencePropertyInfo)conceptInfo;
if (DataStructureCodeGenerator.IsTypeSupported(info.DataStructure))
{
ODataPropertyHelper.GenerateCodeForType(info, codeBuilder, "Guid?", "ID");
}
}
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 GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (UserRequiredPropertyInfo)conceptInfo;
if (IsSupported(info.Property))
{
codeBuilder.InsertCode(CheckDataSnippet(info), WritableOrmDataStructureCodeGenerator.ArgumentValidationTag, info.Property.DataStructure);
}
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (QueryableExtensionInfo)conceptInfo;
DataStructureCodeGenerator.AddInterfaceAndReference(codeBuilder, $"EntityBase<{info.Module.Name}.{info.Name}>", typeof(EntityBase <>), info);
RepositoryHelper.GenerateQueryableRepository(info, codeBuilder, QuerySnippet(info));
codeBuilder.InsertCode(RepositoryFunctionsSnippet(info), RepositoryHelper.RepositoryMembers, info);
}
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 = ((ReferenceCascadeDeleteInfo)conceptInfo);
if (info.Reference.Referenced is IWritableOrmDataStructure)
{
codeBuilder.InsertCode(CodeSnippetDeleteChildren(info), WritableOrmDataStructureCodeGenerator.OldDataLoadedTag, info.Reference.Referenced);
}
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (DataStructureExtendsInfo)conceptInfo;
codeBuilder.InsertCode(
string.Format("[Rhetos.Mvc.Extends(typeof(Rhetos.Mvc.{0}.{1}))]\r\n ",
info.Base.Module.Name, info.Base.Name),
DataStructureCodeGenerator.AttributesTag, info.Extension);
}
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("IValidateRepository", RepositoryHelper.RepositoryInterfaces, info.DataStructure);
codeBuilder.InsertCode(MemberFunctionsSnippet(info), RepositoryHelper.RepositoryMembers, info.DataStructure);
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (RowPermissionsInheritWriteFromInfo)conceptInfo;
codeBuilder.InsertCode(
RowPermissionsUtility.GetInheritSnippet(info.InheritFromInfo, RowPermissionsWriteInfo.PermissionsExpressionName),
RowPermissionsPluginableFiltersInfo.WriteFilterExpressionsTag,
info.Dependency_RowPermissionsWrite);
}
public DepartmentApplication(ILog log,
ICodeBuilder codeBuilder,
IDepartmentRepository departmentRepository)
: base(log)
{
_codeBuilder = codeBuilder;
_departmentRepository = departmentRepository;
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (RowPermissionsInheritExtensionReadInfo)conceptInfo;
codeBuilder.InsertCode(
", " + CsUtility.QuotedString(info.Extends.ExtensionPropertyName()),
RowPermissionsInheritReadCodeGenerator.ExtensionReferenceTag,
info.InheritRead);
}
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 = (KeyPropertyComputedFromInfo)conceptInfo;
if (IsSupported(info.PropertyComputedFrom.Target))
{
codeBuilder.InsertCode(Snippet(info), AlternativeKeyComparerCodeGenerator.CompareKeyPropertyTag, info.Dependency_AlternativeKeyComparer);
}
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
codeBuilder.InsertCode(CodeSnippet);
foreach (var caption in _captionsProvider.Captions.OrderBy(c => c.Key))
{
codeBuilder.InsertResourceData(caption.Key, caption.Value);
}
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (RowPermissionsSingleFunctionRuleInfo)conceptInfo;
codeBuilder.InsertCode(
RowPermissionsUtility.GetSnippetFilterExpression(info, allowNotDeny: false),
RowPermissionsPluginableFiltersInfo.ReadFilterExpressionsTag,
info.Dependency_RowPermissionsRead);
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
DataStructureInfo info = (DataStructureInfo)conceptInfo;
//System.Diagnostics.Debugger.Launch();
codeBuilder.InsertCode(ImplementationCodeSnippet(info), ModuleCodeGenerator.DataStructureTag, info.Module);
codeBuilder.InsertCode(string.Format(@"{0}: _{1}{0},
", info.Name, info.Module.Name), ModuleCodeGenerator.DataStructureReturnTag, info.Module);
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (ActionInfo)conceptInfo;
RepositoryHelper.GenerateRepository(info, codeBuilder);
codeBuilder.InsertCode("IActionRepository", RepositoryHelper.RepositoryInterfaces, info);
codeBuilder.InsertCode(RepositoryFunctionsSnippet(info), RepositoryHelper.RepositoryMembers, info);
codeBuilder.InsertCode(RegisterRepository(info), ModuleCodeGenerator.CommonAutofacConfigurationMembersTag);
}
public void ExtendDatabaseStructure(IConceptInfo conceptInfo, ICodeBuilder codeBuilder, out IEnumerable <Tuple <IConceptInfo, IConceptInfo> > createdDependencies)
{
var info = (LegacyPropertyReferenceInfo)conceptInfo;
createdDependencies = null;
var sourceColumns = info.Columns.Split(',').Select(s => s.Trim()).Select(s => SqlUtility.Identifier(s)).ToArray();
var refColumns = info.ReferencedColumns.Split(',').Select(s => s.Trim()).Select(s => SqlUtility.Identifier(s)).ToArray();
if (sourceColumns.Length != refColumns.Length)
{
throw new DslSyntaxException("Count of references columns does not match count of source columns in " + info.GetUserDescription() + ". "
+ "There are " + sourceColumns.Length + " source columns and " + refColumns.Length + " referenced columns.");
}
string refAlias = SqlUtility.Identifier("ref" + _uniqueNum++);
// Add column to view:
codeBuilder.InsertCode(Sql.Format("LegacyPropertyReferenceDatabaseDefinition_ExtendViewSelect", SqlUtility.Identifier(info.Property.Name), refAlias),
LegacyEntityWithAutoCreatedViewDatabaseDefinition.ViewSelectPartTag, info.Dependency_LegacyEntityWithAutoCreatedView);
var allColumnsEqual = string.Join(" AND ", sourceColumns.Zip(refColumns,
(sCol, rCol) => Sql.Format("LegacyPropertyReferenceDatabaseDefinition_ExtendFromJoin", refAlias, rCol, sCol)));
codeBuilder.InsertCode(Sql.Format("LegacyPropertyReferenceDatabaseDefinition_ExtendViewFrom", SqlUtility.GetFullName(info.ReferencedTable), refAlias, allColumnsEqual),
LegacyEntityWithAutoCreatedViewDatabaseDefinition.ViewFromPartTag, info.Dependency_LegacyEntityWithAutoCreatedView);
// Add columns to instead-of trigger:
foreach (var fkColumn in sourceColumns.Zip(refColumns, Tuple.Create))
{
codeBuilder.InsertCode(Sql.Format("LegacyPropertyReferenceDatabaseDefinition_ExtendTriggerInsert", fkColumn.Item1),
LegacyEntityWithAutoCreatedViewDatabaseDefinition.TriggerInsertPartTag, info.Dependency_LegacyEntityWithAutoCreatedView);
codeBuilder.InsertCode(Sql.Format("LegacyPropertyReferenceDatabaseDefinition_ExtendTriggerSelectForInsert",
fkColumn.Item1,
refAlias,
fkColumn.Item2,
SqlUtility.GetFullName(info.ReferencedTable),
SqlUtility.Identifier(info.Property.Name)),
LegacyEntityWithAutoCreatedViewDatabaseDefinition.TriggerSelectForInsertPartTag, info.Dependency_LegacyEntityWithAutoCreatedView);
codeBuilder.InsertCode(Sql.Format("LegacyPropertyReferenceDatabaseDefinition_ExtendTriggerSelectForUpdate",
fkColumn.Item1,
refAlias,
fkColumn.Item2,
SqlUtility.GetFullName(info.ReferencedTable),
SqlUtility.Identifier(info.Property.Name)),
LegacyEntityWithAutoCreatedViewDatabaseDefinition.TriggerSelectForUpdatePartTag, info.Dependency_LegacyEntityWithAutoCreatedView);
}
codeBuilder.InsertCode(
Sql.Format("LegacyPropertyReferenceDatabaseDefinition_ExtendTriggerFrom", SqlUtility.GetFullName(info.ReferencedTable), refAlias, SqlUtility.Identifier(info.Property.Name)),
LegacyEntityWithAutoCreatedViewDatabaseDefinition.TriggerFromPartTag, info.Dependency_LegacyEntityWithAutoCreatedView);
}
public void Invoke(object[] parameters)
{
// Create compiled type:
if (this.codeBuilder == null)
{
this.host.Log("Parsing template: \"{0}\".", this.templatefileinfo.FullName);
this.fileContent = this.ReadAndParseFile();
this.ReadDirectives(this.fileContent);
this.host.Log("Compiling template: \"{0}\".", this.templatefileinfo.FullName);
this.codeBuilder = this.CreateCodeBuilder(this.GetCodeTemplateDirective()["Language"] ?? GenerationLanguage.DefaultTemplateLanguage);
this.codeBuilder.TemplateInfo = this;
bool succeeded = this.codeBuilder.Compile();
foreach (CompilerError err in this.codeBuilder.CompilerErrors)
{
this.host.Log("Compile {0} {1}: {2}\r\n File \"{3}\", line {4}",
err.IsWarning ? "warning" : "error",
err.ErrorNumber,
err.ErrorText,
err.FileName,
err.Line);
}
if (succeeded == false)
{
throw new CompilationFailedException(this.templatefileinfo.FullName, this.codeBuilder.CompilerErrors);
}
}
// Construct full parameters (add host):
List <object> allparameters = new List <object>();
allparameters.Add(this.host);
allparameters.AddRange(parameters);
// Create instance and invoke:
this.host.Log("Invoking template: \"{0}\".", this.templatefileinfo.FullName);
CodeTemplate instance = (CodeTemplate)Activator.CreateInstance(this.codeBuilder.CompiledType, allparameters.ToArray());
try
{
instance.Generate();
}
catch (RuntimeException)
{
throw;
}
catch (CompilationFailedException)
{
throw;
}
catch (Exception ex)
{
this.host.Log(ex.ToString());
throw new RuntimeException(ex);
}
}
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?");
PropertyHelper.GenerateStorageMapping(referenceGuid, codeBuilder, "System.Data.SqlDbType.UniqueIdentifier");
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 (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.FullName},Property:{info.Name}ID,Referenced:{info.Referenced.FullName}";
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 == info.DataStructure)
{
codeBuilder.InsertCode($@"if (entity.{info.Name}ID != null && entity.{info.Name}ID != entity.ID) yield return entity.{info.Name}ID.Value;
", WritableOrmDataStructureCodeGenerator.PersistenceStorageMapperDependencyResolutionTag, 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);
}
}
}
