public ScaffoldingDto ScaffoldDatabase(string connectionString, string rootNamespace, string contextName)
{
var scaffUtils = new ScaffoldingUtilities();
var csharpUtils = new CSharpUtilities();
var provider = new SqlServerAnnotationProvider();
var customConfiguration = new CustomConfiguration(connectionString, contextName, rootNamespace, true);
var entityTypeWriter = new EntityTypeWriter(csharpUtils);
var dbContextWriter = new SingularDbContextWriter(scaffUtils, csharpUtils);
var configurationFactory = new ConfigurationFactory(provider, csharpUtils, scaffUtils);
var loggerFactory = new LoggerFactory();
var logger = loggerFactory.CreateLogger <SqlServerDatabaseModelFactory>();
var revEngeConfig = new ReverseEngineeringConfiguration {
ConnectionString = connectionString
};
var sqlScaffoldModelFactory = new SingularScaffoldingModelFactory(new LoggerFactory(),
new SqlServerTypeMapper(), new SqlServerDatabaseModelFactory(logger), new CandidateNamingService());
var codeWriter = new StringBuilderCodeWriter(new FileSystemFileService(), dbContextWriter, entityTypeWriter);
var generator = new ReverseEngineeringGenerator(sqlScaffoldModelFactory, configurationFactory, codeWriter);
var metaModel = generator.GetMetadataModel(revEngeConfig);
var modelConfiguration = configurationFactory.CreateModelConfiguration(metaModel, customConfiguration);
var dbContextData = dbContextWriter.WriteCode(modelConfiguration);
var scaffoldingDto = new ScaffoldingDto
{
DbContextSource = dbContextData,
ModelSources = modelConfiguration.EntityConfigurations
.Select(entityConfiguration => entityTypeWriter.WriteCode(entityConfiguration))
.ToImmutableList()
};
return(scaffoldingDto);
}
public static void CompileExpression(IFunctionBuilder functionBuilder, IFunctionData data, string parameterName, string expressionName)
{
var propertyValue = data.Properties[parameterName].Value;
var expressionString = (propertyValue is string) ? propertyValue as string : string.Empty;
SqlStringHandler stringHandler = SqlStringHandler.GetSqlStringHandler(expressionString);
var parameterValues = new string[stringHandler.Expressions.Count];
for (int i = 0; i < parameterValues.Length; i++)
{
parameterValues[i] = functionBuilder.GetParamName(expressionName + i) + ".ToString()";
}
if (parameterValues.Length > 0)
{
functionBuilder.AddCode(string.Format(@"{0} = Twenty57.Linx.Components.Database.Mongo.MongoStringHandler.GetExecutableQuery(
{0},
{1},
new [] {{ {2} }});" ,
functionBuilder.GetParamName(parameterName),
CSharpUtilities.ArrayAsString(stringHandler.Expressions.Select(x => x.MatchText)),
parameterValues.Aggregate((a, b) => a + ",\n" + b)
));
}
}
public MyEntityTypeWriter(
ScaffoldingUtilities scaffoldingUtilities,
CSharpUtilities cSharpUtilities) : base(cSharpUtilities)
{
ScaffoldingUtilities = scaffoldingUtilities;
CSharpUtilities = cSharpUtilities;
}
public virtual void AddColumnNameAndTypeConfiguration(
[NotNull] PropertyConfiguration propertyConfiguration)
{
Check.NotNull(propertyConfiguration, nameof(propertyConfiguration));
var delimitedColumnName =
ExtensionsProvider.For(propertyConfiguration.Property).ColumnName != null &&
ExtensionsProvider.For(propertyConfiguration.Property).ColumnName != propertyConfiguration.Property.Name
? CSharpUtilities.DelimitString(
ExtensionsProvider.For(propertyConfiguration.Property).ColumnName)
: null;
var delimitedColumnTypeName =
ExtensionsProvider.For(propertyConfiguration.Property).ColumnType != null
? CSharpUtilities.DelimitString(
ExtensionsProvider.For(propertyConfiguration.Property).ColumnType)
: null;
if (delimitedColumnName != null)
{
propertyConfiguration.FluentApiConfigurations.Add(
new FluentApiConfiguration(
nameof(RelationalPropertyBuilderExtensions.HasColumnName),
delimitedColumnName)
{
HasAttributeEquivalent = true
});
if (delimitedColumnTypeName == null)
{
propertyConfiguration.AttributeConfigurations.Add(
new AttributeConfiguration(nameof(ColumnAttribute), delimitedColumnName));
}
else
{
propertyConfiguration.FluentApiConfigurations.Add(
new FluentApiConfiguration(
nameof(RelationalPropertyBuilderExtensions.HasColumnType),
delimitedColumnTypeName)
{
HasAttributeEquivalent = true
});
propertyConfiguration.AttributeConfigurations.Add(
new AttributeConfiguration(
nameof(ColumnAttribute),
new[] {
delimitedColumnName,
nameof(ColumnAttribute.TypeName) + " = " + delimitedColumnTypeName
}));
}
}
else if (delimitedColumnTypeName != null)
{
propertyConfiguration.FluentApiConfigurations.Add(
new FluentApiConfiguration(
nameof(RelationalPropertyBuilderExtensions.HasColumnType),
delimitedColumnTypeName));
}
}
public override void GenerateCode(IFunctionBuilder functionBuilder)
{
bool closeFileHandle = FunctionData.Properties.ContainsKey(FileShared.OwnsFileHandlePropertyName) ? FunctionData.Properties[FileShared.OwnsFileHandlePropertyName].GetValue <bool>() : true;
functionBuilder.AddCode(String.Format(
@"var fileHandle = (Twenty57.Linx.Components.File.Common.BinaryFileHandle){0};{1}
return Twenty57.Linx.Components.File.BinaryFileWriteX.WriteFile(
fileHandle,
{2},
{3},
{4},
{5},
message => {6}.Log(message)
);" ,
functionBuilder.GetParamName(FileShared.FilePathPropertyName),
closeFileHandle ? string.Format("{0}fileHandle.LogEvent += message => {1}.Log(message);", Environment.NewLine, functionBuilder.ContextParamName) : string.Empty,
CSharpUtilities.BoolAsString(closeFileHandle),
functionBuilder.GetParamName(BinaryFileWriteShared.ContentsPropertyName),
CSharpUtilities.EnumAsString(FunctionData.Properties[BinaryFileWriteShared.FileDoesNotExistPropertyName].Value),
CSharpUtilities.EnumAsString(FunctionData.Properties[BinaryFileWriteShared.FileExistsPropertyName].Value),
functionBuilder.ContextParamName
));
functionBuilder.AddAssemblyReference(typeof(BinaryFileWriteX));
}
private void GenerateColumnAttribute(IProperty property)
{
var columnName = property.Relational().ColumnName;
var columnType = property.GetConfiguredColumnType();
var delimitedColumnName = columnName != null && columnName != property.Name ? CSharpUtilities.DelimitString(columnName) : null;
var delimitedColumnType = columnType != null?CSharpUtilities.DelimitString(columnType) : null;
if ((delimitedColumnName ?? delimitedColumnType) != null)
{
var columnAttribute = new AttributeWriter(nameof(ColumnAttribute));
if (delimitedColumnName != null)
{
columnAttribute.AddParameter(delimitedColumnName);
}
if (delimitedColumnType != null)
{
columnAttribute.AddParameter($"{nameof(ColumnAttribute.TypeName)} = {delimitedColumnType}");
}
_propertyAnnotations.Add(new Dictionary <string, object>
{
{ "property-annotation", columnAttribute },
});
}
}
/// <summary>
/// Generate entity type properties.
/// </summary>
/// <param name="entityType">Represents an entity type in an <see cref="T:Microsoft.EntityFrameworkCore.Metadata.IModel" />.</param>
protected virtual void GenerateProperties(IEntityType entityType)
{
if (entityType == null)
{
throw new ArgumentNullException(nameof(entityType));
}
var properties = new List <Dictionary <string, object> >();
foreach (var property in entityType.GetProperties().OrderBy(p => p.Scaffolding().ColumnOrdinal))
{
_propertyAnnotations = new List <Dictionary <string, object> >();
if (_useDataAnnotations)
{
GeneratePropertyDataAnnotations(property);
}
properties.Add(new Dictionary <string, object>
{
{ "property-type", CSharpUtilities.GetTypeName(property.ClrType) },
{ "property-name", property.Name },
{ "property-annotations", _propertyAnnotations }
});
}
_templateData.Add("properties", properties);
}
public override void GenerateCode(IFunctionBuilder functionBuilder)
{
this.functionBuilder = functionBuilder;
FileListX_Gen generator = new FileListX_Gen();
generator.Session = new Dictionary <string, object>();
generator.Session.Add("FunctionContextPropertyName", functionBuilder.ContextParamName);
generator.Session.Add("IncludeSubfolders", CSharpUtilities.BoolAsString(FunctionData.Properties[FileListShared.IncludeSubfoldersPropertyName].GetValue <bool>()));
generator.Session.Add("FolderPath", functionBuilder.GetParamName(FileListShared.FolderPathPropertyName));
generator.Session.Add("SearchPattern", functionBuilder.GetParamName(FileListShared.SearchPatternPropertyName));
generator.Session.Add("LoopResults", LoopResults);
generator.Session.Add("ReturnFullPath", FunctionData.Properties[FileListShared.ReturnFullPathPropertyName].GetValue <bool>());
generator.Session.Add("FileInfoTypeName", GetFileInfoTypeName());
generator.Session.Add("OutputTypeName", functionBuilder.GetTypeName(FunctionData.Output));
generator.Session.Add("ExecutionPathName", FileListShared.OutputFileProperty);
generator.Session.Add("ExecutionPathOutputName", functionBuilder.ExecutionPathOutParamName);
generator.Initialize();
functionBuilder.AddCode(generator.TransformText());
functionBuilder.AddAssemblyReference(typeof(FileListX));
}
private void GenerateTableName(IEntityType entityType, IndentedStringBuilder sb)
{
var tableName = entityType.Relational().TableName;
var schema = entityType.Relational().Schema;
var defaultSchema = entityType.Model.Relational().DefaultSchema;
var explicitSchema = schema != null && schema != defaultSchema;
var explicitTable = explicitSchema || tableName != null && tableName != entityType.Scaffolding().DbSetName;
if (explicitTable)
{
var parameterString = CSharpUtilities.DelimitString(tableName);
if (explicitSchema)
{
parameterString += ", " + CSharpUtilities.DelimitString(schema);
}
var lines = new List <string>
{
$".{nameof(RelationalEntityTypeBuilderExtensions.ToTable)}({parameterString})"
};
AppendMultiLineFluentApi(entityType, lines, sb);
}
}
public SqlServerModelConfigurationFactory(
[NotNull] IRelationalAnnotationProvider extensionsProvider,
[NotNull] CSharpUtilities cSharpUtilities,
[NotNull] ModelUtilities modelUtilities)
: base(extensionsProvider, cSharpUtilities, modelUtilities)
{
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public virtual void AddColumnNameAndTypeConfiguration(
[NotNull] PropertyConfiguration propertyConfiguration)
{
Check.NotNull(propertyConfiguration, nameof(propertyConfiguration));
var delimitedColumnName =
AnnotationProvider.For(propertyConfiguration.Property).ColumnName != null &&
AnnotationProvider.For(propertyConfiguration.Property).ColumnName != propertyConfiguration.Property.Name
? CSharpUtilities.DelimitString(
AnnotationProvider.For(propertyConfiguration.Property).ColumnName)
: null;
var delimitedColumnTypeName =
AnnotationProvider.For(propertyConfiguration.Property).ColumnType != null
? CSharpUtilities.DelimitString(
AnnotationProvider.For(propertyConfiguration.Property).ColumnType)
: null;
if (delimitedColumnName != null &&
delimitedColumnTypeName != null)
{
propertyConfiguration.FluentApiConfigurations.Add(
_configurationFactory.CreateFluentApiConfiguration(
/* hasAttributeEquivalent */ true,
nameof(RelationalPropertyBuilderExtensions.HasColumnName),
delimitedColumnName));
propertyConfiguration.FluentApiConfigurations.Add(
_configurationFactory.CreateFluentApiConfiguration(
/* hasAttributeEquivalent */ true,
nameof(RelationalPropertyBuilderExtensions.HasColumnType),
delimitedColumnTypeName));
propertyConfiguration.AttributeConfigurations.Add(
_configurationFactory.CreateAttributeConfiguration(
nameof(ColumnAttribute),
delimitedColumnName,
nameof(ColumnAttribute.TypeName) + " = " + delimitedColumnTypeName));
}
else if (delimitedColumnName != null)
{
propertyConfiguration.FluentApiConfigurations.Add(
_configurationFactory.CreateFluentApiConfiguration(
/* hasAttributeEquivalent */ true,
nameof(RelationalPropertyBuilderExtensions.HasColumnName),
delimitedColumnName));
propertyConfiguration.AttributeConfigurations.Add(
_configurationFactory.CreateAttributeConfiguration(nameof(ColumnAttribute), delimitedColumnName));
}
else if (delimitedColumnTypeName != null)
{
propertyConfiguration.FluentApiConfigurations.Add(
_configurationFactory.CreateFluentApiConfiguration(
/* hasAttributeEquivalent */ true,
nameof(RelationalPropertyBuilderExtensions.HasColumnType),
delimitedColumnTypeName));
propertyConfiguration.AttributeConfigurations.Add(
_configurationFactory.CreateAttributeConfiguration(
nameof(ColumnAttribute), nameof(ColumnAttribute.TypeName) + " = " + delimitedColumnTypeName));
}
}
public virtual void AddConnectionStringConfiguration()
{
_onConfiguringConfigurations.Add(
new OptionsBuilderConfiguration(
UseMethodName
+ "("
+ CSharpUtilities.GenerateVerbatimStringLiteral(CustomConfiguration.ConnectionString)
+ ")"));
}
public SqlServerModelConfiguration(
[NotNull] IModel model,
[NotNull] CustomConfiguration customConfiguration,
[NotNull] IRelationalAnnotationProvider extensionsProvider,
[NotNull] CSharpUtilities cSharpUtilities,
[NotNull] ModelUtilities modelUtilities)
: base(model, customConfiguration, extensionsProvider, cSharpUtilities, modelUtilities)
{
}
protected RelationalMetadataModelProvider([NotNull] ILoggerFactory loggerFactory,
[NotNull] ModelUtilities modelUtilities, [NotNull] CSharpUtilities cSharpUtilities)
{
Check.NotNull(loggerFactory, nameof(loggerFactory));
Check.NotNull(modelUtilities, nameof(modelUtilities));
Logger = loggerFactory.CreateCommandsLogger();
CSharpUtilities = cSharpUtilities;
ModelUtilities = modelUtilities;
}
public CustomConfigurationFactory(
IRelationalAnnotationProvider extensionsProvider,
CSharpUtilities cSharpUtilities,
ScaffoldingUtilities scaffoldingUtilities)
: base(
extensionsProvider,
cSharpUtilities,
scaffoldingUtilities)
{
}
private void AddDependentAndPrincipalNavigationPropertyAnnotations([NotNull] IModel codeGenModel)
{
Check.NotNull(codeGenModel, nameof(codeGenModel));
var entityTypeToExistingIdentifiers = new Dictionary <IEntityType, List <string> >();
foreach (var entityType in codeGenModel.EntityTypes)
{
var existingIdentifiers = new List <string>();
entityTypeToExistingIdentifiers.Add(entityType, existingIdentifiers);
existingIdentifiers.Add(entityType.Name);
existingIdentifiers.AddRange(
ModelUtilities.OrderedProperties(entityType).Select(p => p.Name));
}
foreach (var entityType in codeGenModel.EntityTypes)
{
var dependentEndExistingIdentifiers = entityTypeToExistingIdentifiers[entityType];
foreach (var foreignKey in entityType.GetForeignKeys().Cast <ForeignKey>())
{
// set up the name of the navigation property on the dependent end of the foreign key
var dependentEndNavigationPropertyCandidateName =
ModelUtilities.GetDependentEndCandidateNavigationPropertyName(foreignKey);
var dependentEndNavigationPropertyName =
CSharpUtilities.GenerateCSharpIdentifier(
dependentEndNavigationPropertyCandidateName,
dependentEndExistingIdentifiers,
NavigationUniquifier);
foreignKey.AddAnnotation(
AnnotationNameDependentEndNavPropName,
dependentEndNavigationPropertyName);
dependentEndExistingIdentifiers.Add(dependentEndNavigationPropertyName);
// set up the name of the navigation property on the principal end of the foreign key
var principalEndExistingIdentifiers =
entityTypeToExistingIdentifiers[foreignKey.PrincipalEntityType];
var principalEndNavigationPropertyCandidateName =
foreignKey.IsSelfReferencing()
? string.Format(
CultureInfo.CurrentCulture,
SelfReferencingPrincipalEndNavigationNamePattern,
dependentEndNavigationPropertyName)
: ModelUtilities.GetPrincipalEndCandidateNavigationPropertyName(foreignKey);
var principalEndNavigationPropertyName =
CSharpUtilities.GenerateCSharpIdentifier(
principalEndNavigationPropertyCandidateName,
principalEndExistingIdentifiers,
NavigationUniquifier);
foreignKey.AddAnnotation(
AnnotationNamePrincipalEndNavPropName,
principalEndNavigationPropertyName);
principalEndExistingIdentifiers.Add(principalEndNavigationPropertyName);
}
}
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public virtual string ClassName()
{
var annotatedName = AnnotationProvider.For(Model).DatabaseName;
if (!string.IsNullOrEmpty(annotatedName))
{
return(CSharpUtilities.GenerateCSharpIdentifier(annotatedName + DbContextSuffix, null));
}
return(DefaultDbContextName);
}
public SqliteMetadataModelProvider(
[NotNull] ILoggerFactory loggerFactory,
[NotNull] ModelUtilities modelUtilities,
[NotNull] CSharpUtilities cSharpUtilities,
[NotNull] SqliteReverseTypeMapper typeMapper)
: base(loggerFactory, modelUtilities, cSharpUtilities)
{
Check.NotNull(typeMapper, nameof(typeMapper));
_typeMapper = typeMapper;
}
public override string ClassName()
{
var builder = new SqlConnectionStringBuilder(CustomConfiguration.ConnectionString);
if (builder.InitialCatalog != null)
{
return(CSharpUtilities.GenerateCSharpIdentifier(
builder.InitialCatalog + DbContextSuffix, null));
}
return(base.ClassName());
}
public ModelConfigurationFactory(
[NotNull] IRelationalAnnotationProvider extensionsProvider,
[NotNull] CSharpUtilities cSharpUtilities,
[NotNull] ModelUtilities modelUtilities)
{
Check.NotNull(extensionsProvider, nameof(extensionsProvider));
Check.NotNull(cSharpUtilities, nameof(cSharpUtilities));
Check.NotNull(modelUtilities, nameof(modelUtilities));
ExtensionsProvider = extensionsProvider;
CSharpUtilities = cSharpUtilities;
ModelUtilities = modelUtilities;
}
public override string ClassName()
{
var sqliteConnection = new SqliteConnectionStringBuilder(CustomConfiguration.ConnectionString);
if (sqliteConnection.DataSource != null)
{
var fileName = Path.GetFileNameWithoutExtension(sqliteConnection.DataSource);
return(CSharpUtilities.GenerateCSharpIdentifier(
fileName + DbContextSuffix, null));
}
return(base.ClassName());
}
public virtual void AddDefaultValueConfiguration(
[NotNull] PropertyConfiguration propertyConfiguration)
{
Check.NotNull(propertyConfiguration, nameof(propertyConfiguration));
if (ExtensionsProvider.For(propertyConfiguration.Property).DefaultValue != null)
{
propertyConfiguration.FluentApiConfigurations.Add(
new FluentApiConfiguration(
nameof(RelationalPropertyBuilderExtensions.HasDefaultValue),
CSharpUtilities.GenerateLiteral(
(dynamic)ExtensionsProvider.For(propertyConfiguration.Property).DefaultValue)));
}
}
public virtual void AddDefaultExpressionConfiguration(
[NotNull] PropertyConfiguration propertyConfiguration)
{
Check.NotNull(propertyConfiguration, nameof(propertyConfiguration));
if (ExtensionsProvider.For(propertyConfiguration.Property).GeneratedValueSql != null)
{
propertyConfiguration.FluentApiConfigurations.Add(
new FluentApiConfiguration(
nameof(RelationalPropertyBuilderExtensions.HasDefaultValueSql),
CSharpUtilities.DelimitString(
ExtensionsProvider.For(propertyConfiguration.Property).GeneratedValueSql)));
}
}
public SqlServerMetadataModelProvider(
[NotNull] ILoggerFactory loggerFactory,
[NotNull] ModelUtilities modelUtilities,
[NotNull] CSharpUtilities cSharpUtilities,
[NotNull] IRelationalAnnotationProvider extensionsProvider,
[NotNull] SqlServerLiteralUtilities sqlServerLiteralUtilities)
: base(loggerFactory, modelUtilities, cSharpUtilities)
{
Check.NotNull(extensionsProvider, nameof(extensionsProvider));
Check.NotNull(sqlServerLiteralUtilities, nameof(sqlServerLiteralUtilities));
ExtensionsProvider = extensionsProvider;
_sqlServerLiteralUtilities = sqlServerLiteralUtilities;
}
private void GenerateIndex(IIndex index, IndentedStringBuilder sb)
{
var lines = new List <string>
{
$".{nameof(EntityTypeBuilder.HasIndex)}(e => {GenerateLambdaToKey(index.Properties, "e")})"
};
var annotations = index.GetAnnotations().ToList();
if (!string.IsNullOrEmpty((string)index[RelationalAnnotationNames.Name]))
{
lines.Add($".{nameof(RelationalIndexBuilderExtensions.HasName)}({CSharpUtilities.DelimitString(index.Relational().Name)})");
RemoveAnnotation(ref annotations, RelationalAnnotationNames.Name);
}
if (index.IsUnique)
{
lines.Add($".{nameof(IndexBuilder.IsUnique)}()");
}
if (index.Relational().Filter != null)
{
lines.Add($".{nameof(RelationalIndexBuilderExtensions.HasFilter)}({CSharpUtilities.DelimitString(index.Relational().Filter)})");
RemoveAnnotation(ref annotations, RelationalAnnotationNames.Filter);
}
var annotationsToRemove = new List <IAnnotation>();
foreach (var annotation in annotations)
{
if (_annotationCodeGenerator.IsHandledByConvention(index, annotation))
{
annotationsToRemove.Add(annotation);
}
else
{
var line = _annotationCodeGenerator.GenerateFluentApi(index, annotation, Language);
if (line != null)
{
lines.Add(line);
annotationsToRemove.Add(annotation);
}
}
}
lines.AddRange(GenerateAnnotations(annotations.Except(annotationsToRemove)));
AppendMultiLineFluentApi(index.DeclaringEntityType, lines, sb);
}
/// <summary>
/// Create the template output
/// </summary>
public virtual string TransformText()
{
this.Write("\r\n");
this.Write("\r\nvar beginTransactionX = new Twenty57.Linx.Components.Database.BeginTransaction." +
"BeginTransactionX(\r\n\t");
#line 12 "D:\Hg\Linx5 Components\Database\Code\Database\BeginTransaction\BeginTransaction_Gen.tt"
this.Write(this.ToStringHelper.ToStringWithCulture(CSharpUtilities.EnumAsString(ConnectionType)));
#line default
#line hidden
this.Write(",\r\n\t");
#line 13 "D:\Hg\Linx5 Components\Database\Code\Database\BeginTransaction\BeginTransaction_Gen.tt"
this.Write(this.ToStringHelper.ToStringWithCulture(ConnectionStringPropertyName));
#line default
#line hidden
this.Write(",\r\n\tSystem.Data.IsolationLevel.");
#line 14 "D:\Hg\Linx5 Components\Database\Code\Database\BeginTransaction\BeginTransaction_Gen.tt"
this.Write(this.ToStringHelper.ToStringWithCulture(IsolationLevelName));
#line default
#line hidden
this.Write(");\r\nbeginTransactionX.Transaction.LogEvent += message => ");
#line 15 "D:\Hg\Linx5 Components\Database\Code\Database\BeginTransaction\BeginTransaction_Gen.tt"
this.Write(this.ToStringHelper.ToStringWithCulture(FunctionContextProperty));
#line default
#line hidden
this.Write(".Log(message);\r\n");
#line 16 "D:\Hg\Linx5 Components\Database\Code\Database\BeginTransaction\BeginTransaction_Gen.tt"
this.Write(this.ToStringHelper.ToStringWithCulture(ExecutionPathOutputName));
#line default
#line hidden
this.Write(" = beginTransactionX.Select(transaction => new Twenty57.Linx.Plugin.Common.CodeGe" +
"neration.NextResult(");
#line 16 "D:\Hg\Linx5 Components\Database\Code\Database\BeginTransaction\BeginTransaction_Gen.tt"
this.Write(this.ToStringHelper.ToStringWithCulture(CSharpUtilities.ToVerbatimString(ExecutionPathName)));
#line default
#line hidden
this.Write(", transaction));\r\n");
return(this.GenerationEnvironment.ToString());
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public virtual void AddDefaultValueConfiguration(
[NotNull] PropertyConfiguration propertyConfiguration)
{
Check.NotNull(propertyConfiguration, nameof(propertyConfiguration));
if (AnnotationProvider.For(propertyConfiguration.Property).DefaultValue != null)
{
propertyConfiguration.FluentApiConfigurations.Add(
_configurationFactory.CreateFluentApiConfiguration(
/* hasAttributeEquivalent */ false,
nameof(RelationalPropertyBuilderExtensions.HasDefaultValue),
CSharpUtilities.GenerateLiteral(
(dynamic)AnnotationProvider.For(propertyConfiguration.Property).DefaultValue)));
}
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public virtual void AddComputedExpressionConfiguration(
[NotNull] PropertyConfiguration propertyConfiguration)
{
Check.NotNull(propertyConfiguration, nameof(propertyConfiguration));
if (AnnotationProvider.For(propertyConfiguration.Property).ComputedColumnSql != null)
{
propertyConfiguration.FluentApiConfigurations.Add(
_configurationFactory.CreateFluentApiConfiguration(
/* hasAttributeEquivalent */ false,
nameof(RelationalPropertyBuilderExtensions.HasComputedColumnSql),
CSharpUtilities.DelimitString(
AnnotationProvider.For(propertyConfiguration.Property).ComputedColumnSql)));
}
}
public override void GenerateCode(IFunctionBuilder functionBuilder)
{
RobocopyShared.ModeOption modeOption = FunctionData.Properties[RobocopyShared.ModePropertyName].GetValue <RobocopyShared.ModeOption>();
functionBuilder.AddCode(string.Format("Twenty57.Linx.Components.File.RobocopyX.Execute({0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10},{11},{12},{13},{14},{15},{16},{17},{18},{19},{20},{21},{22},{23},{24},{25},{26},{27},{28},{29},{30},{31},{32},{33},{34},{35},{36},{37},{38},message => {39}.Log(message));",
functionBuilder.GetParamName(RobocopyShared.SourceDirectoryPropertyName)
, functionBuilder.GetParamName(RobocopyShared.TargetDirectoryPropertyName)
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.CopySubdirectoriesPropertyName].GetValue <bool>())
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.IncludeEmptySubdirectoriesPropertyName].GetValue <bool>())
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.RestartModePropertyName].GetValue <bool>())
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.BackupModePropertyName].GetValue <bool>())
, functionBuilder.GetParamName(RobocopyShared.NumberOfRetriesPropertyName)
, functionBuilder.GetParamName(RobocopyShared.TimeBetweenRetriesPropertyName)
, functionBuilder.GetParamName(RobocopyShared.FilePatternPropertyName)
, functionBuilder.GetParamName(RobocopyShared.ExcludeFilesPropertyName)
, functionBuilder.GetParamName(RobocopyShared.ExcludeDirectoriesPropertyName)
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.ExcludesChangedFilesPropertyName].GetValue <bool>())
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.ExcludesNewerFilesPropertyName].GetValue <bool>())
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.ExcludesOlderFilesPropertyName].GetValue <bool>())
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.ExcludesExtraFilesAndDirectoriesPropertyName].GetValue <bool>())
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.ExcludesLonelyFilesAndDirectoriesPropertyName].GetValue <bool>())
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.IncludesSameFilesPropertyName].GetValue <bool>())
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.IncludesTweakedFilesPropertyName].GetValue <bool>())
, functionBuilder.GetParamName(RobocopyShared.MaxFileSizePropertyName)
, functionBuilder.GetParamName(RobocopyShared.MinFileSizePropertyName)
, functionBuilder.GetParamName(RobocopyShared.MaxAgePropertyName)
, functionBuilder.GetParamName(RobocopyShared.MinAgePropertyName)
, functionBuilder.GetParamName(RobocopyShared.MaxLastAccessDatePropertyName)
, functionBuilder.GetParamName(RobocopyShared.MinLastAccessDatePropertyName)
, functionBuilder.GetParamName(RobocopyShared.LogFilePropertyName)
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.OverwriteFilePropertyName].GetValue <bool>())
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.ListFilesOnlyPropertyName].GetValue <bool>())
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.LogAllExtraFilesPropertyName].GetValue <bool>())
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.VerbosePropertyName].GetValue <bool>())
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.IncludeSourceFileTimestampsPropertyName].GetValue <bool>())
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.IncludeFullPathPropertyName].GetValue <bool>())
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.LogSizeAsBytesPropertyName].GetValue <bool>())
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.ExcludeFileSizePropertyName].GetValue <bool>())
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.ExcludeFileClassPropertyName].GetValue <bool>())
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.ExcludeFileNamesPropertyName].GetValue <bool>())
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.ExcludeDirectoryNamesPropertyName].GetValue <bool>())
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.ExcludeProgressPropertyName].GetValue <bool>())
, CSharpUtilities.BoolAsString(FunctionData.Properties[RobocopyShared.IncludeETAPropertyName].GetValue <bool>())
, CSharpUtilities.EnumAsString(modeOption)
, functionBuilder.ContextParamName));
functionBuilder.AddAssemblyReference(typeof(Robocopy));
}
public RazorTemplating(
[NotNull] ICompilationService compilationService,
[NotNull] MetadataReferencesProvider metadataReferencesProvider,
[NotNull] ModelUtilities modelUtilities,
[NotNull] CSharpUtilities csharpUtiliies)
{
Check.NotNull(compilationService, nameof(compilationService));
Check.NotNull(metadataReferencesProvider, nameof(metadataReferencesProvider));
Check.NotNull(modelUtilities, nameof(modelUtilities));
Check.NotNull(csharpUtiliies, nameof(csharpUtiliies));
_compilationService = compilationService;
_metadataReferencesProvider = metadataReferencesProvider;
_modelUtilities = modelUtilities;
_csharpUtiliies = csharpUtiliies;
}
