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 = (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 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(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 = (RegisteredInterfaceImplementationInfo)conceptInfo;
codeBuilder.InsertCode(RegisterRepository(info), ModuleCodeGenerator.CommonAutofacConfigurationMembersTag);
codeBuilder.InsertCode(RegisterImplementationName(info), ModuleCodeGenerator.RegisteredInterfaceImplementationNameTag);
}
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 = (ComputationUseExecutionContextInfo)conceptInfo;
codeBuilder.InsertCode(", Common.ExecutionContext", DataStructureUtility.ComputationAdditionalParametersTypeTag, info.Computation);
codeBuilder.InsertCode(", _executionContext", DataStructureUtility.ComputationAdditionalParametersArgumentTag, info.Computation);
}
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(SnippetInfrastructureKeepSynchronizedMetadata(), ModuleCodeGenerator.CommonInfrastructureMembersTag);
codeBuilder.InsertCode(SnippetRegisterInfrastructure(), ModuleCodeGenerator.CommonAutofacConfigurationMembersTag);
}
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 = (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 = (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 = (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)
{
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)
{
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 = (EntityHistoryInfo)conceptInfo;
codeBuilder.InsertCode(FilterInterfaceSnippet(info), RepositoryHelper.RepositoryInterfaces, info.Dependency_ChangesEntity);
codeBuilder.InsertCode(FilterImplementationSnippet(info), RepositoryHelper.RepositoryMembers, info.Dependency_ChangesEntity);
codeBuilder.InsertCode(AdditionalParameterSnippet(info), DataStructureCodeGenerator.BodyTag, info.Entity);
codeBuilder.InsertCode(CreateHistoryOnUpdateSnippet(info), WritableOrmDataStructureCodeGenerator.OldDataLoadedTag, info.Entity);
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (QueryWithParameterInfo)conceptInfo;
codeBuilder.InsertCode(InterfaceName(info), RepositoryHelper.RepositoryInterfaces, info.DataStructure);
codeBuilder.InsertCode(MemberFunctionsSnippet(info), RepositoryHelper.RepositoryMembers, info.DataStructure);
codeBuilder.InsertCode(RegisterRepository(info), ModuleCodeGenerator.CommonAutofacConfigurationMembersTag);
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (EntityHistoryPropertyInfo)conceptInfo;
codeBuilder.InsertCode(string.Format(",\r\n {0} = olditem.{0}", info.Property.Name),
EntityHistoryCodeGenerator.ClonePropertiesTag, info.EntityHistory);
codeBuilder.InsertCode(string.Format("\r\n ret.{0} = item.{0};", info.Property.Name),
EntityHistoryInfo.ClonePropertiesTag, info.EntityHistory);
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (DeactivatableInfo)conceptInfo;
codeBuilder.InsertCode(DefaultSnippet(info), WritableOrmDataStructureCodeGenerator.OldDataLoadedTag, info.Entity);
codeBuilder.InsertCode("Rhetos.Dom.DefaultConcepts.IDeactivatable", DataStructureCodeGenerator.InterfaceTag, info.Entity);
codeBuilder.AddReferencesFromDependency(typeof(IDeactivatable));
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (DataStructureExtendsInfo) conceptInfo;
if (info.Extension is IOrmDataStructure && info.Base is IOrmDataStructure)
{
codeBuilder.InsertCode(BasePropertyOnExtension(info), OrmDataStructureMappingGenerator.MembersTag, info.Extension);
codeBuilder.InsertCode(ExtensionPropertyOnBase(info), OrmDataStructureMappingGenerator.MembersTag, info.Base);
}
}
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(
string.Format("modelBuilder.Entity<Common.Queryable.{0}_{1}>().HasOptional(t => t.{2}).WithMany().HasForeignKey(t => t.{2}ID);\r\n ",
info.DataStructure.Module.Name, info.DataStructure.Name, info.Name),
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 (ReferencePropertyConstraintDatabaseDefinition.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.Name + "ID") + @", "
+ 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 = (ReportFileInfo)conceptInfo;
codeBuilder.InsertCode(RepositoryFunctionsSnippet(info), RepositoryHelper.RepositoryMembers, info);
codeBuilder.InsertCode("IReportRepository", RepositoryHelper.RepositoryInterfaces, info);
codeBuilder.InsertCode(RegisterRepository(info), ModuleCodeGenerator.CommonAutofacConfigurationMembersTag);
codeBuilder.AddReferencesFromDependency(typeof(ReportFile));
codeBuilder.AddReferencesFromDependency(typeof(IReportRepository));
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (DataStructureInfo)conceptInfo;
if (info is IWritableOrmDataStructure)
{
codeBuilder.InsertCode("IWritableRepository", RepositoryHelper.RepositoryInterfaces, info);
codeBuilder.InsertCode(MemberFunctionsSnippet(info), RepositoryHelper.RepositoryMembers, info);
codeBuilder.InsertCode(RegisterRepository(info), ModuleCodeGenerator.CommonAutofacConfigurationMembersTag);
}
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
DataStructureInfo info = (DataStructureInfo)conceptInfo;
if (DslUtility.IsQueryable(info))
{
codeBuilder.InsertCode(SnippetQueryableClass(info), DomInitializationCodeGenerator.CommonQueryableMemebersTag);
codeBuilder.InsertCode("IDetachOverride", DataStructureQueryableCodeGenerator.InterfaceTag, info);
codeBuilder.InsertCode("bool IDetachOverride.Detaching { get; set; }\r\n\r\n ", DataStructureQueryableCodeGenerator.MembersTag, info);
}
}
public static void GenerateCodeForType(PropertyInfo info, ICodeBuilder codeBuilder, string propertyType)
{
codeBuilder.InsertCode(PropertySnippet(info, propertyType), DataStructureCodeGenerator.BodyTag, info.DataStructure);
codeBuilder.InsertCode("[DataMember]", AttributeTag, info);
if (DslUtility.IsQueryable(info.DataStructure))
if (info.Name != "ID")
codeBuilder.InsertCode(
string.Format(",\r\n {0} = item.{0}", info.Name),
RepositoryHelper.AssignSimplePropertyTag, info.DataStructure);
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (DataStructureInfo)conceptInfo;
if (info is IWritableOrmDataStructure)
{
codeBuilder.InsertCode("IWritableRepository", RepositoryHelper.RepositoryInterfaces, info);
codeBuilder.InsertCode(MemberFunctionsSnippet(info), RepositoryHelper.RepositoryMembers, info);
codeBuilder.InsertCode(RegisterRepository(info), ModuleCodeGenerator.CommonAutofacConfigurationMembersTag);
codeBuilder.AddReferencesFromDependency(typeof(Rhetos.Utilities.ExceptionsUtility));
}
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (ReportDataInfo)conceptInfo;
codeBuilder.InsertCode(ServiceRegistrationCodeSnippet(info), InitialCodeGenerator.ServiceRegistrationTag);
codeBuilder.InsertCode(ServiceInitializationCodeSnippet(info), InitialCodeGenerator.ServiceInitializationTag);
codeBuilder.InsertCode(ServiceDefinitionCodeSnippet(info), InitialCodeGenerator.RhetosRestClassesTag);
codeBuilder.AddReferencesFromDependency(typeof(Rhetos.RestGenerator.Utilities.ServiceUtility));
codeBuilder.AddReferencesFromDependency(typeof(Rhetos.RestGenerator.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 == "Claim")
{
codeBuilder.InsertCode("Rhetos.Dom.DefaultConcepts.IClaimRepository", RepositoryHelper.RepositoryInterfaces, info);
codeBuilder.InsertCode(MemberFunctionsSnippet, RepositoryHelper.RepositoryMembers, info);
codeBuilder.InsertCode(RegisterRepository(info), ModuleCodeGenerator.CommonAutofacConfigurationMembersTag);
codeBuilder.AddReferencesFromDependency(typeof(Rhetos.Dom.DefaultConcepts.IClaimRepository));
}
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (RepositoryUsesInfo)conceptInfo;
var type = Type.GetType(info.PropertyType);
if (type == null)
throw new DslSyntaxException(info, "Could not find type '" + info.PropertyType + "'.");
codeBuilder.InsertCode("private readonly " + type.FullName + " " + info.PropertyName + ";\r\n ", RepositoryHelper.RepositoryPrivateMembers, info.DataStructure);
codeBuilder.InsertCode(", " + type.FullName + " " + info.PropertyName, RepositoryHelper.ConstructorArguments, info.DataStructure);
codeBuilder.InsertCode("this." + info.PropertyName + " = " + info.PropertyName + ";\r\n ", RepositoryHelper.ConstructorCode, info.DataStructure);
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (ComputeForNewItemsInfo) conceptInfo;
var persistedExtension = info.EntityComputedFrom.Target;
var uniqueSuffixInTarget = GetUniqueSuffixWithinTarget(info);
codeBuilder.InsertCode(RecomputeForNewItemsSnippet(info, uniqueSuffixInTarget), WritableOrmDataStructureCodeGenerator.OnSaveTag1, info.EntityComputedFrom.Target);
if (!string.IsNullOrWhiteSpace(info.FilterSaveExpression))
codeBuilder.InsertCode(FilterSaveFunction(info, uniqueSuffixInTarget), RepositoryHelper.RepositoryMembers, info.EntityComputedFrom.Target);
}
public static void AddInterfaceAndReference(ICodeBuilder codeBuilder, string typeName, Type type, DataStructureInfo dataStructureInfo)
{
codeBuilder.InsertCode(typeName, DataStructureQueryableCodeGenerator.InterfaceTag, dataStructureInfo);
codeBuilder.AddReferencesFromDependency(type);
}
public override void GenerateCode(InitializationConcept conceptInfo, ICodeBuilder codeBuilder)
{
codeBuilder.InsertCode(
@" <Function Name=""StringEqualsCaseInsensitive"" ReturnType=""Edm.Boolean"">
<Parameter Name=""a"" Type=""Edm.String"" />
<Parameter Name=""b"" Type=""Edm.String"" />
<DefiningExpression>a = b</DefiningExpression>
</Function>
<Function Name=""StringNotEqualsCaseInsensitive"" ReturnType=""Edm.Boolean"">
<Parameter Name=""a"" Type=""Edm.String"" />
<Parameter Name=""b"" Type=""Edm.String"" />
<DefiningExpression>a != b</DefiningExpression>
</Function>
<Function Name=""StringIsLessThen"" ReturnType=""Edm.Boolean"">
<Parameter Name=""a"" Type=""Edm.String"" />
<Parameter Name=""b"" Type=""Edm.String"" />
<DefiningExpression>a < b</DefiningExpression>
</Function>
<Function Name=""StringIsLessThenOrEqual"" ReturnType=""Edm.Boolean"">
<Parameter Name=""a"" Type=""Edm.String"" />
<Parameter Name=""b"" Type=""Edm.String"" />
<DefiningExpression>a <= b</DefiningExpression>
</Function>
<Function Name=""StringIsGreaterThen"" ReturnType=""Edm.Boolean"">
<Parameter Name=""a"" Type=""Edm.String"" />
<Parameter Name=""b"" Type=""Edm.String"" />
<DefiningExpression>a > b</DefiningExpression>
</Function>
<Function Name=""StringIsGreaterThenOrEqual"" ReturnType=""Edm.Boolean"">
<Parameter Name=""a"" Type=""Edm.String"" />
<Parameter Name=""b"" Type=""Edm.String"" />
<DefiningExpression>a >= b</DefiningExpression>
</Function>
<Function Name=""IntStartsWith"" ReturnType=""Edm.Boolean"">
<Parameter Name=""a"" Type=""Edm.Int32"" />
<Parameter Name=""b"" Type=""Edm.String"" />
<DefiningExpression>CAST(a as Edm.String) LIKE b + '%'</DefiningExpression>
</Function>
<Function Name=""StringStartsWithCaseInsensitive"" ReturnType=""Edm.Boolean"">
<Parameter Name=""a"" Type=""Edm.String"" />
<Parameter Name=""b"" Type=""Edm.String"" />
<DefiningExpression>a LIKE b + '%'</DefiningExpression>
</Function>
<Function Name=""StringEndsWithCaseInsensitive"" ReturnType=""Edm.Boolean"">
<Parameter Name=""a"" Type=""Edm.String"" />
<Parameter Name=""b"" Type=""Edm.String"" />
<DefiningExpression>a LIKE '%' + b</DefiningExpression>
</Function>
<Function Name=""StringContainsCaseInsensitive"" ReturnType=""Edm.Boolean"">
<Parameter Name=""a"" Type=""Edm.String"" />
<Parameter Name=""b"" Type=""Edm.String"" />
<DefiningExpression>a LIKE '%' + b + '%'</DefiningExpression>
</Function>
<Function Name=""StringLike"" ReturnType=""Edm.Boolean"">
<Parameter Name=""text"" Type=""Edm.String"" />
<Parameter Name=""pattern"" Type=""Edm.String"" />
<DefiningExpression>text LIKE pattern</DefiningExpression>
</Function>
<Function Name=""IntCastToString"" ReturnType=""Edm.String"">
<Parameter Name=""a"" Type=""Edm.Int32"" />
<DefiningExpression>CAST(a as Edm.String)</DefiningExpression>
</Function>
", EntityFrameworkMapping.ConceptualModelTag);
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
codeBuilder.InsertCode("AddInterceptor(new Rhetos.Dom.DefaultConcepts.Persistence.FullTextSearchInterceptor());\r\n ", DomInitializationCodeGenerator.EntityFrameworkConfigurationTag);
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
codeBuilder.InsertCode(
"internal class DontTrackHistory<T> : List<T>\r\n {\r\n }\r\n ",
ModuleCodeGenerator.CommonNamespaceMembersTag);
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (OnInitializationInfo)conceptInfo;
codeBuilder.InsertCode(GetSnippet(info), WritableOrmDataStructureCodeGenerator.InitializationTag, info.SaveMethod.Entity);
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
codeBuilder.InsertCode(CodeSnippet);
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (InvalidDataMarkPropertyInfo)conceptInfo;
codeBuilder.InsertCode(AdditionalInvalidMessageSnippet(info), InvalidDataCodeGenerator.UserMessageAppend, info);
}
