public void Enact(IGenerationContext context, object target)
{
var fieldContext = new GenerationContext(context.Builders, new TypeFieldGenerationContextNode(
(TypeGenerationContextNode) context.Node,
_member));
_member.FieldInfo.SetValue(target, _datasource.Next(fieldContext));
}
protected virtual void WriteDataContextProcedures(CodeWriter writer, DbLinq.Schema.Dbml.Database schema, GenerationContext context)
{
foreach (var procedure in schema.Functions)
{
WriteDataContextProcedure(writer, procedure, context);
}
}
public override void WriteClassHeader(CodeWriter writer, DbLinq.Schema.Dbml.Table table, GenerationContext context)
{
using (writer.WriteRegion(string.Format("{0} handling", typeof(INotifyPropertyChanging).Name)))
{
const string eventName = "PropertyChanging"; // do not change, part of INotifyPropertyChanging
const string emptyArgs = "emptyChangingEventArgs";
// event
writer.WriteEvent(SpecificationDefinition.Public, eventName, typeof(PropertyChangingEventHandler).Name);
writer.WriteLine();
// empty event arg
writer.WriteField(SpecificationDefinition.Private | SpecificationDefinition.Static,
writer.GetAssignmentExpression(emptyArgs, writer.GetNewExpression(
writer.GetMethodCallExpression(typeof(PropertyChangingEventArgs).Name, "\"\""))),
typeof(PropertyChangingEventArgs).Name);
// method
using (writer.WriteMethod(SpecificationDefinition.Protected | SpecificationDefinition.Virtual,
sendPropertyChangingMethod, null))
{
using (writer.WriteIf(writer.GetDifferentExpression(eventName, writer.GetNullExpression())))
{
writer.WriteLine(writer.GetStatement(writer.GetMethodCallExpression(eventName,
writer.GetThisExpression(), emptyArgs)));
}
}
}
}
private void WriteDataContextProcedure(CodeWriter writer, Function procedure, GenerationContext context)
{
if (procedure == null || procedure.Name == null)
{
//Logger.Write(Level.Error, "CodeGenStoredProc: Error L33 Invalid storedProcedure object");
writer.WriteCommentLine("error L33 Invalid storedProcedure object");
return;
}
var functionAttribute = NewAttributeDefinition<FunctionAttribute>();
functionAttribute["Name"] = procedure.Name;
functionAttribute["IsComposable"] = procedure.IsComposable;
SpecificationDefinition specifications;
if (procedure.AccessModifierSpecified)
specifications = GetSpecificationDefinition(procedure.AccessModifier);
else
specifications = SpecificationDefinition.Public;
if (procedure.ModifierSpecified)
specifications |= GetSpecificationDefinition(procedure.Modifier);
using (writer.WriteAttribute(functionAttribute))
using (writer.WriteMethod(specifications, GetProcedureName(procedure),
GetProcedureType(procedure), GetProcedureParameters(procedure)))
{
string result = WriteProcedureBodyMethodCall(writer, procedure, context);
WriteProcedureBodyOutParameters(writer, procedure, result, context);
WriteProcedureBodyReturnValue(writer, procedure, result, context);
}
writer.WriteLine();
}
public void Enact(IGenerationContext context, object target)
{
var propertyContext = new GenerationContext(context.Builders, new TypePropertyGenerationContextNode(
(TypeGenerationContextNode) context.Node,
mMember));
mMember.PropertyInfo.SetValue(target, mDatasource.Next(propertyContext), null);
}
protected virtual void WriteClass(CodeWriter writer, Table table, Database schema, GenerationContext context)
{
writer.WriteLine();
string entityBase = context.Parameters.EntityBase;
if (string.IsNullOrEmpty(entityBase))
entityBase = schema.EntityBase;
var specifications = SpecificationDefinition.Partial;
if (table.Type.AccessModifierSpecified)
specifications |= GetSpecificationDefinition(table.Type.AccessModifier);
else
specifications |= SpecificationDefinition.Public;
if (table.Type.ModifierSpecified)
specifications |= GetSpecificationDefinition(table.Type.Modifier);
var tableAttribute = NewAttributeDefinition<TableAttribute>();
tableAttribute["Name"] = table.Name;
using (writer.WriteAttribute(tableAttribute))
using (writer.WriteClass(specifications,
table.Type.Name, entityBase, context.Parameters.EntityInterfaces))
{
WriteClassHeader(writer, table, context);
WriteCustomTypes(writer, table, schema, context);
WriteClassExtensibilityDeclarations(writer, table, context);
WriteClassProperties(writer, table, context);
if (context.Parameters.GenerateEqualsHash)
WriteClassEqualsAndHash(writer, table, context);
WriteClassChildren(writer, table, schema, context);
WriteClassParents(writer, table, schema, context);
WriteClassChildrenAttachment(writer, table, schema, context);
WriteClassCtor(writer, table, schema, context);
}
}
private List<UserCategorySettings<ObjectId>> CreateCategory(
GenerationContext<UserDeliveryTypeSettings<ObjectId>> context)
{
ObjectId userID = context.ForeignEntity.UserID;
var category = SignaloBotEntityCreator<ObjectId>.CreateUserCategorySettings(userID, 1);
return new List<UserCategorySettings<ObjectId>>() { category };
}
protected virtual void WriteDataContextCtors(CodeWriter writer, Database schema, Type contextBaseType, GenerationContext context)
{
// ctor taking a connections tring
WriteDataContextCtor(writer, schema, contextBaseType,
new[] { new ParameterDefinition { Name = "connectionString", Type = typeof(string) } },
new[] { "connectionString" },
new[] { typeof(string) },
context);
// the two constructors below have the same prototype, so they are mutually exclusive
// the base class requires a IVendor
if (!WriteDataContextCtor(writer, schema, contextBaseType,
new[] { new ParameterDefinition { Name = "connection", Type = typeof(IDbConnection) } },
new[] { "connection", writer.GetNewExpression(writer.GetMethodCallExpression(writer.GetLiteralFullType(context.SchemaLoader.Vendor.GetType()))) },
new[] { typeof(IDbConnection), typeof(IVendor) },
context))
{
// OR the base class requires no IVendor
WriteDataContextCtor(writer, schema, contextBaseType,
new[] { new ParameterDefinition { Name = "connection", Type = typeof(IDbConnection) } },
new[] { "connection" },
new[] { typeof(IDbConnection) },
context);
}
// ctor(string, MappingSource)
WriteDataContextCtor(writer, schema, contextBaseType,
new[] {
new ParameterDefinition { Name = "connection", Type = typeof(string) },
new ParameterDefinition { Name = "mappingSource", Type = typeof(MappingSource) },
},
new[] { "connection", "mappingSource" },
new[] { typeof(string), typeof (MappingSource) },
context);
// ctor(IDbConnection, MappingSource)
WriteDataContextCtor(writer, schema, contextBaseType,
new[] {
new ParameterDefinition { Name = "connection", Type = typeof(IDbConnection) },
new ParameterDefinition { Name = "mappingSource", Type = typeof(MappingSource) },
},
new[] { "connection", "mappingSource" },
new[] { typeof(IDbConnection), typeof(MappingSource) },
context);
// just in case you'd like to specify another vendor than the one who helped generating this file
WriteDataContextCtor(writer, schema, contextBaseType,
new[] {
new ParameterDefinition { Name = "connection", Type = typeof(IDbConnection) },
new ParameterDefinition { Name = "vendor", Type = typeof(IVendor) },
},
new[] { "connection", "vendor" },
new[] { typeof(IDbConnection), typeof(IVendor) },
context);
WriteDataContextCtor(writer, schema, contextBaseType,
new[] {
new ParameterDefinition { Name = "connection", Type = typeof(IDbConnection) },
new ParameterDefinition { Name = "mappingSource", Type = typeof(MappingSource) },
new ParameterDefinition { Name = "vendor", Type = typeof(IVendor) },
},
new[] { "connection", "mappingSource", "vendor" },
new[] { typeof(IDbConnection), typeof(MappingSource), typeof(IVendor) },
context);
}
public void TestSetup()
{
IEngineConfiguration configuration = new EngineConfiguration();
IEngineConventionProvider conventionProvider = new Mock<IEngineConventionProvider>().Object;
GenerationConfiguration repository = new GenerationConfiguration(configuration, conventionProvider, 10);
configuration.RegisterType(typeof(SimpleUser));
mGenerationSession = new GenerationContext(repository);
}
public void SetupObjects()
{
mSourceMock = new Mock<IDatasource>();
mParentNode = new TypeGenerationContextNode(null, null);
mContext = new GenerationContext(null, mParentNode);
mAction = new ObjectPropertySetFromSourceAction((EngineTypePropertyMember)
ReflectionHelper.GetMember<SimplePropertyClass>(x => x.SomeProperty), mSourceMock.Object);
}
public object Generate(GenerationContext context)
{
var user = context.RootAs<User>();
var timeDiference = DateTime.Now - user.Dob;
var age = timeDiference.Days / 365;
return user.Sex == Sex.Male
? GetMinAgeForMaleAged(age)
: GetMinAgeForFemaleAged(age);
}
public IEnumerable<INeed> GetNeeds(IGenerationContext context)
{
if (_myNeed.Key==null)
{
var buildContext = context.BuildContext;
var genCtx = new GenerationContext(context.Container, _nestedRegistration, buildContext, _type.GetMethod("Invoke").GetParameters());
_myNeed.Key = genCtx.GenerateFunc(_type);
}
yield return _myNeed;
}
public void SetupObjects()
{
mSourceMock = new Mock<IDatasource>();
mParentNode = new TypeGenerationContextNode(null, null);
mContext = new GenerationContext(null, mParentNode);
mDoubleArgMethod = (EngineTypeMethodMember)ReflectionHelper.GetMember(typeof(SimpleMethodClass).GetMethod("SetSomething", new Type[] { typeof(string), typeof(string) }));
mDoubleArgAction = new ObjectMethodInvokeFromSourceAction(mDoubleArgMethod, new IDatasource[] { mSourceMock.Object, mSourceMock.Object });
}
public void Single_Passes_Context_Through_To_Session()
{
Mock<IObjectBuilder> builder = new Mock<IObjectBuilder>();
Mock<IGenerationConfiguration> builderRepository = new Mock<IGenerationConfiguration>();
builderRepository.Setup(x => x.GetBuilderForType(typeof (Object))).Returns(builder.Object);
IGenerationContext context = new GenerationContext(builderRepository.Object);
context.Single<Object>().Get();
builder.Verify(x => x.CreateObject(context), Times.Once());
}
protected virtual void WriteClasses(CodeWriter writer, Database schema, GenerationContext context)
{
IEnumerable<Table> tables = schema.Tables;
var types = context.Parameters.GenerateTypes;
if (types.Count > 0)
tables = tables.Where(t => types.Contains(t.Type.Name));
foreach (var table in tables)
WriteClass(writer, table, schema, context);
}
public void Enact(IGenerationContext context, object target)
{
List<Object> paramList = new List<object>();
var methodContext = new GenerationContext(context.Builders,
new TypeMethodGenerationContextNode((TypeGenerationContextNode)context.Node, mMember));
foreach (var source in mSources)
{
paramList.Add(source.Next(methodContext));
}
mMember.MethodInfo.Invoke(target, paramList.ToArray());
}
protected override string WriteProcedureBodyMethodCall(CodeWriter writer, DbLinq.Schema.Dbml.Function procedure, GenerationContext context)
{
// picrap: there may be some more elegant ways to invoke a stored procedure, because ExecuteMethodCall is
// for internal use only
const string result = "result";
var parametersBuilder = new StringBuilder();
foreach (var parameter in procedure.Parameters)
{
if (parameter.DirectionIn)
parametersBuilder.AppendFormat(", {0}", parameter.Name);
}
writer.WriteLine(string.Format("var {0} = ExecuteMethodCall(this, (MethodInfo)MethodBase.GetCurrentMethod(){1});",
result, parametersBuilder));
return result;
}
protected virtual bool WriteDataContextCtor(CodeWriter writer, Database schema, Type contextBaseType,
ParameterDefinition[] parameters, string[] baseCallParameterNames, Type[] baseCallParameterTypes,
GenerationContext context)
{
// if we have a contextBaseType, then check that we can do it
if (contextBaseType != null)
{
var ctor = contextBaseType.GetConstructor(baseCallParameterTypes);
if (ctor == null)
return false;
}
using (writer.WriteCtor(SpecificationDefinition.Public, schema.Class, parameters, baseCallParameterNames))
{
writer.WriteLine(writer.GetStatement(writer.GetMethodCallExpression("OnCreated")));
}
writer.WriteLine();
return true;
}
public override void WriteClassHeader(CodeWriter writer, DbLinq.Schema.Dbml.Table table, GenerationContext context)
{
using (writer.WriteRegion(string.Format("{0} handling", typeof(INotifyPropertyChanged).Name)))
{
const string eventName = "PropertyChanged"; // do not change, part of INotifyPropertyChanged
const string propertyNameName = "propertyName";
// event
writer.WriteEvent(SpecificationDefinition.Public, eventName, typeof(PropertyChangedEventHandler).Name);
writer.WriteLine();
// method
using (writer.WriteMethod(SpecificationDefinition.Protected | SpecificationDefinition.Virtual,
sendPropertyChangedMethod, null, new ParameterDefinition { Name = propertyNameName, Type = typeof(string) }))
{
using (writer.WriteIf(writer.GetDifferentExpression(eventName, writer.GetNullExpression())))
{
writer.WriteLine(writer.GetStatement(writer.GetMethodCallExpression(eventName,
writer.GetThisExpression(),
writer.GetNewExpression(writer.GetMethodCallExpression(typeof(PropertyChangedEventArgs).Name,
propertyNameName)))));
}
}
}
}
//методы генерации данных
private UserDeliveryTypeSettings<ObjectId> CreateDeliveryType(
GenerationContext context)
{
ObjectId userID = ObjectId.GenerateNewId();
return SignaloBotEntityCreator<ObjectId>.CreateUserDeliveryTypeSettings(userID);
}
private List<UserTopicSettings<ObjectId>> CreateTopic(
GenerationContext<UserDeliveryTypeSettings<ObjectId>> context)
{
ObjectId userID = context.ForeignEntity.UserID;
var topic = SignaloBotEntityCreator<ObjectId>.CreateUserTopicSettings(userID);
return new List<UserTopicSettings<ObjectId>>() { topic };
}
protected virtual void WriteClassEqualsAndHash(CodeWriter writer, Table table, GenerationContext context)
{
List<DbLinq.Schema.Dbml.Column> primaryKeys = table.Type.Columns.Where(c => c.IsPrimaryKey).ToList();
if (primaryKeys.Count == 0)
{
writer.WriteLine("#warning L189 table {0} has no primary key. Multiple C# objects will refer to the same row.",
table.Name);
return;
}
using (writer.WriteRegion(string.Format("GetHashCode(), Equals() - uses column {0} to look up objects in liveObjectMap",
string.Join(", ", primaryKeys.Select(pk => pk.Member).ToList().ToArray()))))
{
// GetHashCode
using (writer.WriteMethod(SpecificationDefinition.Public | SpecificationDefinition.Override,
"GetHashCode", typeof(int)))
{
string hashCode = null;
foreach (var primaryKey in primaryKeys)
{
var member = writer.GetVariableExpression(primaryKey.Storage);
string primaryKeyHashCode = writer.GetMethodCallExpression(writer.GetMemberExpression(member, "GetHashCode"));
if (primaryKey.CanBeNull
|| GetType(primaryKey.Type, false).IsClass) // this patch to ensure that even if DB does not allow nulls,
// our in-memory object won't generate a fault
{
var isNullExpression = writer.GetEqualExpression(member, writer.GetNullExpression());
var nullExpression = writer.GetLiteralValue(0);
primaryKeyHashCode = "(" + writer.GetTernaryExpression(isNullExpression, nullExpression, primaryKeyHashCode) + ")";
}
if (string.IsNullOrEmpty(hashCode))
hashCode = primaryKeyHashCode;
else
hashCode = writer.GetXOrExpression(hashCode, primaryKeyHashCode);
}
writer.WriteLine(writer.GetReturnStatement(hashCode));
}
writer.WriteLine();
// Equals
string otherAsObject = "o";
using (writer.WriteMethod(SpecificationDefinition.Public | SpecificationDefinition.Override,
"Equals", typeof(bool), new ParameterDefinition { Type = typeof(object), Name = otherAsObject }))
{
string other = "other";
writer.WriteLine(writer.GetStatement(writer.GetAssignmentExpression(
writer.GetDeclarationExpression(other, table.Type.Name),
writer.GetCastExpression(otherAsObject, table.Type.Name,
false))));
using (writer.WriteIf(writer.GetEqualExpression(other, writer.GetNullExpression())))
{
writer.WriteLine(writer.GetReturnStatement(writer.GetLiteralValue(false)));
}
string andExpression = null;
foreach (var primaryKey in primaryKeys)
{
var member = writer.GetVariableExpression(primaryKey.Storage);
string primaryKeyTest = writer.GetMethodCallExpression(
writer.GetMemberExpression(
writer.GetMemberExpression(
writer.GetGenericName("System.Collections.Generic.EqualityComparer", primaryKey.Type),
"Default"),
"Equals"),
member,
writer.GetMemberExpression(other, member));
if (string.IsNullOrEmpty(andExpression))
andExpression = primaryKeyTest;
else
andExpression = writer.GetAndExpression(andExpression, primaryKeyTest);
}
writer.WriteLine(writer.GetReturnStatement(andExpression));
}
}
}
private void EnactActionsOnObject(IGenerationContext context, object createdObject)
{
var typeContext = new GenerationContext(context.Builders, new TypeGenerationContextNode(context.Node, createdObject));
foreach (var action in this.mActions)
{
action.Enact(typeContext, createdObject);
}
}
public static string WriteFile(GenerationContext context)
{
var usings = new List <string>
{
@"using AspNetCore.Client;",
"using AspNetCore.Client.Authorization;",
"using AspNetCore.Client.Exceptions;",
"using AspNetCore.Client.Http;",
"using AspNetCore.Client.RequestModifiers;",
"using AspNetCore.Client.Serializers;",
"using Flurl.Http;",
"using Microsoft.Extensions.DependencyInjection;",
"using System;",
"using System.Linq;",
"using System.Collections.Generic;",
"using System.Net;",
"using System.Net.Http;",
"using System.Runtime.CompilerServices;",
"using System.Threading;",
"using System.Threading.Tasks;",
"using Microsoft.AspNetCore.SignalR.Client;",
"using Microsoft.AspNetCore.Http.Connections;",
"using Microsoft.AspNetCore.Http.Connections.Client;",
"using Microsoft.AspNetCore.SignalR.Protocol;",
"using Microsoft.Extensions.Logging;",
"using System.IO;",
"using System.Threading.Channels;",
"using AspNetCore.Client.GeneratorExtensions;"
}.Union(context.UsingStatements)
.Distinct()
.OrderBy(x => x)
.ToList();
return
($@"//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated from a template.
// Manual changes to this file may cause unexpected behavior in your application.
// Manual changes to this file will be overwritten if the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
{string.Join(Environment.NewLine, usings)}
namespace {Settings.ClientNamespace}
{{
{string.Join(Environment.NewLine, context.HttpClients.Select(HttpClassWriter.WriteErrorMessage).NotNull())}
{string.Join(Environment.NewLine, context.HubClients.Select(SignalRClassWriter.WriteErrorMessage).NotNull())}
{HttpClassWriter.WriteInstaller(context)}
{HttpClassWriter.WriteBaseClients()}
{HttpClassWriter.WriteRepositories(context)}
}}
{HttpClassWriter.WriteVersionBlocks(context)}
{SignalRClassWriter.WriteVersionBlocks(context)}
");
}
/// <summary>
/// Writes attach/detach method
/// </summary>
/// <param name="writer"></param>
/// <param name="table"></param>
/// <param name="schema"></param>
/// <param name="context"></param>
protected virtual void WriteClassChildrenAttachment(CodeWriter writer, Table table, Database schema, GenerationContext context)
{
var children = GetClassChildren(table).ToList();
if (children.Count > 0)
{
using (writer.WriteRegion("Attachement handlers"))
{
foreach (var child in children)
{
// the reverse child is the association seen from the child
// we're going to use it...
var reverseChild = schema.GetReverseAssociation(child);
// ... to get the parent name
var memberName = reverseChild.Member;
var entityParameter = new ParameterDefinition { Name = "entity", LiteralType = child.Type };
// the Attach event handler sets the child entity parent to "this"
using (writer.WriteMethod(SpecificationDefinition.Private, GetChildAttachMethodName(child),
null, entityParameter))
{
writer.WriteLine(
writer.GetStatement(
writer.GetAssignmentExpression(
writer.GetMemberExpression(entityParameter.Name, memberName),
writer.GetThisExpression())));
}
writer.WriteLine();
// the Detach event handler sets the child entity parent to null
using (writer.WriteMethod(SpecificationDefinition.Private, GetChildDetachMethodName(child),
null, entityParameter))
{
writer.WriteLine(
writer.GetStatement(
writer.GetAssignmentExpression(
writer.GetMemberExpression(entityParameter.Name, memberName),
writer.GetNullExpression())));
}
writer.WriteLine();
}
}
}
}
protected virtual void GenerateModelExtensions(ITable table)
{
if (!Options.GenerateModelExtensions)
{
return;
}
if (!Options.GenerateModelsInterfaces && !Options.GenerateModels)
{
throw new Exception("Impossible to generate model extensions because neither GenerateModels or GenerateModelsInterfaces is activated.");
}
// full paths to model or interface
var modelFullClassName = ModelClassFullName(table);
var modelInterfaceFullName = ModelInterfaceFullName(table);
// poco.
var pocoFullInterfaceName = TableInterfaceFullName(table);
var pocoFullClassName = TableClassFullName(table);
// poco type.
var pocoClassName = TableClassName(table);
var pocoClassNamespace = TableNamespace(table);
var pocoClass = GenerationContext.FindClass(pocoClassName, pocoClassNamespace);
var modelExtensionNamespaceName = ModelExtensionsNamespace(table);
var modelExtensionClassName = ModelExtensionsClassName(table);
var fileBuilder = ResolveModelExtensionFileBuilder(table);
fileBuilder.Namespace(modelExtensionNamespaceName, true, ns =>
{
ns.Class(c =>
{
// set basic info.
c.Partial(true).Static(true).Name(modelExtensionClassName);
var finalEntityType = Options.GenerateInterfaces ? pocoFullInterfaceName : pocoFullClassName;
var finalModelType = Options.GenerateModelsInterfaces ? modelInterfaceFullName : modelFullClassName;
c.Method(m =>
{
m
.AccessModifier(AccessModifiers.Public)
.IsStatic(true)
.Name("ToModel")
.ReturnType("void")
.Parameter(p => p.Name("source").Type($"this {finalEntityType}"))
.Parameter(p => p.Name("model").Type(finalModelType));
table.Columns.ForEach(column =>
{
m.RawLine($"model.{column.Name} = source.{column.Name}");
});
});
c.Method(m =>
{
m
.AccessModifier(AccessModifiers.Public)
.IsStatic(true)
.Name("FromModel")
.ReturnType("void")
.Parameter(p => p.Name("model").Type($"this {finalModelType}"))
.Parameter(p => p.Name("destination").Type(finalEntityType))
.Parameter(p => p.Name("ignorePrimaryKey").Type("bool").DefaultValue("true"))
;
table.Columns.ForEach(column =>
{
var rawLine = "";
bool isPropertyNullable = IsModelPropertyNullable(column); // column.IsNullable || ShouldGenerateModelPropertyAsNullable(column);
if (isPropertyNullable && !column.IsNullable)
{
var matchingProp = pocoClass.FindByMeta <PropertyBuilder>(column);
var ternary = TernaryBuilder
.Create()
.RawCondition(rc => rc.Condition($"model.{column.Name} != null"))
.True(RawInlineBuilder.Create(
$"destination.{column.Name} = ({matchingProp.GetTypeName()})model.{column.Name}"))
.False(RawInlineBuilder.Create(
$"destination.{column.Name} = default({matchingProp.GetTypeName()})"));
rawLine = $"destination.{column.Name} = {ternary.GenerateInline()}";
}
else
{
rawLine = $"destination.{column.Name} = model.{column.Name}";
}
if (column.IsPrimaryKey)
{
m.Add(IfBuilder.Create().RawCondition(rc => rc.Condition($"ignorePrimaryKey != true")).Add(RawLineBuilder.Create(rawLine)));
}
else
{
m.RawLine(rawLine);
}
});
});
});
});
}
public void SetUp()
{
_testClass = new GenerationContext();
}
private void ProduceCollectionProperties(string instanceName, object instance, GenerationContext context)
{
List <ExpressionSyntax> initNodes = new List <ExpressionSyntax>();
foreach (var propertyInfo in Meta.CollectionProperties)
{
if (!Meta.IsDefault(propertyInfo, instance))
{
var value = Meta.Value(propertyInfo, instance);
var collCreation =
propertyInfo.PropertyType.IsTuple()
? ProceedTuple(_tgr, value.GetTupleValues(), context)
: ProceedCollection(_tgr, propertyInfo.PropertyType, value as IEnumerable, context);
var ae = SafeAssignment(instanceName, propertyInfo.Name, collCreation);
context.LateBound.Enqueue(ExpressionStatement(ae));
context.AddUsing(propertyInfo.PropertyType.Namespace);
}
}
}
private void ProduceDictionaryProperties(string instanceName, object instance, GenerationContext context)
{
foreach (var propertyInfo in Meta.DictionaryProperties)
{
if (!Meta.IsDefault(propertyInfo, instance))
{
var value = Meta.Value(propertyInfo, instance);
var collCreation =
ProceedDictionary(_tgr, propertyInfo.PropertyType, value as IDictionary, context);
var ae = SafeAssignment(instanceName, propertyInfo.Name, collCreation);
context.LateBound.Enqueue(ExpressionStatement(ae));
context.AddUsing(propertyInfo.PropertyType.Namespace);
}
}
}
private void GenerateFilesSection(
GenerationContext context,
IFileGenerator fileGenerator)
{
Strings projectFiles = context.Project.GetSourceFilesForConfigurations(context.ProjectConfigurations);
// Add source files
var allFiles = new List <Vcxproj.ProjectFile>();
var includeFiles = new List <Vcxproj.ProjectFile>();
var sourceFiles = new List <Vcxproj.ProjectFile>();
var contentFiles = new List <Vcxproj.ProjectFile>();
foreach (string file in projectFiles)
{
var projectFile = new Vcxproj.ProjectFile(context, file);
allFiles.Add(projectFile);
}
allFiles.Sort((l, r) => { return(string.Compare(l.FileNameProjectRelative, r.FileNameProjectRelative, StringComparison.InvariantCultureIgnoreCase)); });
// type -> files
var customSourceFiles = new Dictionary <string, List <Vcxproj.ProjectFile> >();
foreach (var projectFile in allFiles)
{
string type = null;
if (context.Project.ExtensionBuildTools.TryGetValue(projectFile.FileExtension, out type))
{
List <Vcxproj.ProjectFile> files = null;
if (!customSourceFiles.TryGetValue(type, out files))
{
files = new List <Vcxproj.ProjectFile>();
customSourceFiles[type] = files;
}
files.Add(projectFile);
}
else if (context.Project.SourceFilesCompileExtensions.Contains(projectFile.FileExtension) ||
(string.Compare(projectFile.FileExtension, ".rc", StringComparison.OrdinalIgnoreCase) == 0))
{
sourceFiles.Add(projectFile);
}
else if (string.Compare(projectFile.FileExtension, ".h", StringComparison.OrdinalIgnoreCase) == 0)
{
includeFiles.Add(projectFile);
}
else
{
contentFiles.Add(projectFile);
}
}
// Write header files
if (includeFiles.Count > 0)
{
fileGenerator.Write(Template.Project.ProjectFilesBegin);
foreach (var file in includeFiles)
{
using (fileGenerator.Declare("file", file))
fileGenerator.Write(Template.Project.ProjectFilesHeader);
}
fileGenerator.Write(Template.Project.ProjectFilesEnd);
}
// Write content files
if (contentFiles.Count > 0)
{
fileGenerator.Write(Template.Project.ProjectFilesBegin);
foreach (var file in contentFiles)
{
using (fileGenerator.Declare("file", file))
fileGenerator.Write(Template.Project.ContentSimple);
}
fileGenerator.Write(Template.Project.ProjectFilesEnd);
}
// Write Android project files
fileGenerator.Write(Template.Project.ItemGroupBegin);
if (_isGradleBuild)
{
foreach (var file in context.AndroidPackageProject.GradleTemplateFiles)
{
using (fileGenerator.Declare("gradleTemplateFile", file))
fileGenerator.Write(Template.Project.GradleTemplate);
}
}
else
{
using (fileGenerator.Declare("antBuildXml", context.AndroidPackageProject.AntBuildXml))
using (fileGenerator.Declare("antProjectPropertiesFile", context.AndroidPackageProject.AntProjectPropertiesFile))
using (fileGenerator.Declare("androidManifest", context.AndroidPackageProject.AndroidManifest))
{
fileGenerator.Write(Template.Project.AntBuildXml);
fileGenerator.Write(Template.Project.AndroidManifest);
fileGenerator.Write(Template.Project.AntProjectPropertiesFile);
}
}
fileGenerator.Write(Template.Project.ItemGroupEnd);
}
private void GenerateImpl(
GenerationContext context,
List <string> generatedFiles,
List <string> skipFiles)
{
GenerateConfOptions(context);
var fileGenerator = new XmlFileGenerator();
// xml begin header
string toolsVersion = context.DevelopmentEnvironmentsRange.MinDevEnv.GetVisualProjectToolsVersionString();
using (fileGenerator.Declare("toolsVersion", toolsVersion))
fileGenerator.Write(Template.Project.ProjectBegin);
VsProjCommon.WriteCustomProperties(context.Project.CustomProperties, fileGenerator);
VsProjCommon.WriteProjectConfigurationsDescription(context.ProjectConfigurations, fileGenerator);
// xml end header
string androidTargetsPath = Options.GetConfOption <Options.Android.General.AndroidTargetsPath>(context.ProjectConfigurations, rootpath: context.ProjectDirectoryCapitalized);
var firstConf = context.ProjectConfigurations.First();
_androidBuildType = Options.GetOptionValue("androidBuildType", context.ProjectConfigurationOptions.Values, FileGeneratorUtilities.RemoveLineTag);
using (fileGenerator.Declare("androidBuildType", _androidBuildType))
using (fileGenerator.Declare("projectName", firstConf.ProjectName))
using (fileGenerator.Declare("guid", firstConf.ProjectGuid))
using (fileGenerator.Declare("toolsVersion", toolsVersion))
using (fileGenerator.Declare("androidTargetsPath", Util.EnsureTrailingSeparator(androidTargetsPath)))
{
fileGenerator.Write(Template.Project.ProjectDescription);
}
fileGenerator.Write(VsProjCommon.Template.PropertyGroupEnd);
foreach (var platform in context.PresentPlatforms.Values)
{
platform.GeneratePlatformSpecificProjectDescription(context, fileGenerator);
}
fileGenerator.Write(Template.Project.ImportAndroidDefaultProps);
foreach (var platform in context.PresentPlatforms.Values)
{
platform.GeneratePostDefaultPropsImport(context, fileGenerator);
}
// configuration general
foreach (Project.Configuration conf in context.ProjectConfigurations)
{
context.Configuration = conf;
using (fileGenerator.Declare("platformName", Util.GetPlatformString(conf.Platform, conf.Project, conf.Target)))
using (fileGenerator.Declare("conf", conf))
using (fileGenerator.Declare("options", context.ProjectConfigurationOptions[conf]))
{
fileGenerator.Write(Template.Project.ProjectConfigurationsGeneral);
}
}
// .props files
fileGenerator.Write(Template.Project.ProjectAfterConfigurationsGeneral);
VsProjCommon.WriteProjectCustomPropsFiles(context.Project.CustomPropsFiles, context.ProjectDirectoryCapitalized, fileGenerator);
VsProjCommon.WriteConfigurationsCustomPropsFiles(context.ProjectConfigurations, context.ProjectDirectoryCapitalized, fileGenerator);
fileGenerator.Write(Template.Project.ProjectAfterImportedProps);
string androidPackageDirectory = context.AndroidPackageProject.AntBuildRootDirectory;
// configuration ItemDefinitionGroup
foreach (Project.Configuration conf in context.ProjectConfigurations)
{
context.Configuration = conf;
using (fileGenerator.Declare("platformName", Util.GetPlatformString(conf.Platform, conf.Project, conf.Target)))
using (fileGenerator.Declare("conf", conf))
using (fileGenerator.Declare("options", context.ProjectConfigurationOptions[conf]))
using (fileGenerator.Declare("androidPackageDirectory", androidPackageDirectory))
{
fileGenerator.Write(Template.Project.ProjectConfigurationBeginItemDefinition);
{
if (!_isGradleBuild)
{
fileGenerator.Write(Template.Project.AntPackage);
}
}
fileGenerator.Write(Template.Project.ProjectConfigurationEndItemDefinition);
}
}
if (_isGradleBuild)
{
using (fileGenerator.Declare("gradlePlugin", context.AndroidPackageProject.GradlePlugin))
using (fileGenerator.Declare("gradleVersion", context.AndroidPackageProject.GradleVersion))
{
fileGenerator.Write(VsProjCommon.Template.ItemDefinitionGroupBegin);
fileGenerator.Write(Template.Project.GradlePackage);
fileGenerator.Write(VsProjCommon.Template.ItemDefinitionGroupEnd);
}
}
GenerateFilesSection(context, fileGenerator);
// .targets
fileGenerator.Write(Template.Project.ProjectTargets);
GenerateProjectReferences(context, fileGenerator);
// Environment variables
var environmentVariables = context.ProjectConfigurations.Select(conf => conf.Platform).Distinct().SelectMany(platform => context.PresentPlatforms[platform].GetEnvironmentVariables(context));
VsProjCommon.WriteEnvironmentVariables(environmentVariables, fileGenerator);
fileGenerator.Write(Template.Project.ProjectEnd);
// remove all line that contain RemoveLineTag
fileGenerator.RemoveTaggedLines();
MemoryStream cleanMemoryStream = fileGenerator.ToMemoryStream();
FileInfo projectFileInfo = new FileInfo(context.ProjectPath + ProjectExtension);
if (context.Builder.Context.WriteGeneratedFile(context.Project.GetType(), projectFileInfo, cleanMemoryStream))
{
generatedFiles.Add(projectFileInfo.FullName);
}
else
{
skipFiles.Add(projectFileInfo.FullName);
}
}
public AllOfSchemaGenerator(ILocatedOpenApiElement <OpenApiSchema> schemaElement, GenerationContext context)
: base(schemaElement, context)
{
}
private Comment<ObjectId> CreateComment(GenerationContext<ContentBase<ObjectId>> context)
{
ObjectId currentID = ObjectId.GenerateNewId();
ObjectId? branchCommentID;
ObjectId? parentCommentID;
DateTime publishTime = DateTime.UtcNow.AddDays(-1).AddMinutes(context.TotalEntityCounter);
switch (context.ItemsPerForeignEntityCounter)
{
case 0:
branchCommentID = null;
parentCommentID = null;
break;
case 1:
branchCommentID = null;
parentCommentID = null;
context.Bag["branchCommentID"] = currentID;
break;
default:
branchCommentID = (ObjectId)context.Bag["branchCommentID"];
parentCommentID = (ObjectId)context.Bag["lastCommentID"];
break;
}
context.Bag["lastCommentID"] = currentID;
UserEssentials user = RandomHelper.PickFromList(_users);
return new Comment<ObjectId>()
{
ContentID = context.ForeignEntity.ContentID,
CommentID = currentID,
BranchCommentID = branchCommentID,
ParentCommentID = branchCommentID,
AddTimeUtc = publishTime,
UserUpdateTimeUtc = publishTime,
Content = "Comment content",
DownVotes = 0,
UpVotes = 0,
State = CommentState.Inserted,
AuthorID = user.ID,
AuthorAvatar = user.Avatar,
AuthorName = user.Name
};
}
protected TypeGeneratorBase(ILocatedOpenApiElement <T> element, GenerationContext context)
: base(context)
{
Element = element ?? throw new ArgumentNullException(nameof(element));
}
public MethodGenerationContext(GenerationContext generationContext)
{
GenerationContext = generationContext;
}
public void CanConstruct()
{
var instance = new GenerationContext();
Assert.That(instance, Is.Not.Null);
}
private List <StatementSyntax> ProduceInlineableProperties(string instanceName, object instance, GenerationContext context)
{
List <StatementSyntax> initNodes = new List <StatementSyntax>();
foreach (var propertyInfo in Meta.InlineProperties)
{
if (!Meta.IsDefault(propertyInfo, instance))
{
var pName = propertyInfo.Name;
// "value"
var propValue = TypeInitConstructor.Construct(propertyInfo.PropertyType, Meta.Value(propertyInfo, instance));
var invocation = SafeAssignment(instanceName, pName, propValue);
initNodes.Add(ExpressionStatement(invocation));
var u = ExtractEnumUsing(propertyInfo.PropertyType);
context.AddUsing(u);
}
}
return(initNodes);
}
public BaseTypeEnricher(GenerationContext context)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
}
public BuildUriMethodGenerator(GenerationContext context, ISerializationNamespace serializationNamespace)
{
Context = context ?? throw new ArgumentNullException(nameof(context));
SerializationNamespace = serializationNamespace ?? throw new ArgumentNullException(nameof(serializationNamespace));
}
public ClientGenerator(GenerationContext generationContext, IRootNamespace rootNamespace)
: base(generationContext, rootNamespace)
{
}
protected virtual void WriteProcedureBodyOutParameters(CodeWriter writer, DbLinq.Schema.Dbml.Function procedure, string result, GenerationContext context)
{
int parameterIndex = 0;
foreach (var parameter in procedure.Parameters)
{
if (parameter.DirectionOut)
{
WriteProcedureBodyOutParameter(writer, parameter, result, parameterIndex, context);
}
parameterIndex++;
}
}
protected abstract void Generate(GenerationContext context);
protected virtual void WriteProcedureBodyReturnValue(CodeWriter writer, DbLinq.Schema.Dbml.Function procedure, string result, GenerationContext context)
{
Type returnType = GetProcedureType(procedure);
if (returnType != null)
{
writer.WriteLine(writer.GetReturnStatement(writer.GetCastExpression(writer.GetMemberExpression(result, "ReturnValue"), writer.GetLiteralType(returnType), true)));
}
}
protected virtual void WriteDataContextProcedures(CodeWriter writer, DbLinq.Schema.Dbml.Database schema, GenerationContext context)
{
foreach (var procedure in schema.Functions)
{
WriteDataContextProcedure(writer, procedure, context);
}
}
/// <summary>
/// Writes class ctor.
/// EntitySet initializations
/// </summary>
/// <param name="writer"></param>
/// <param name="table"></param>
/// <param name="schema"></param>
/// <param name="context"></param>
protected virtual void WriteClassCtor(CodeWriter writer, Table table, Database schema, GenerationContext context)
{
using (writer.WriteRegion("ctor"))
using (writer.WriteCtor(SpecificationDefinition.Public, table.Type.Name, new ParameterDefinition[0], null))
{
// children are EntitySet
foreach (var child in GetClassChildren(table))
{
// if the association has a storage, we use it. Otherwise, we use the property name
var entitySetMember = child.Storage ?? child.Member;
writer.WriteLine(writer.GetStatement(
writer.GetAssignmentExpression(
entitySetMember,
writer.GetNewExpression(writer.GetMethodCallExpression(
writer.GetGenericName(TypeExtensions.GetShortName(typeof(EntitySet<>)), child.Type),
GetChildAttachMethodName(child),
GetChildDetachMethodName(child)
))
)
));
}
// the parents are the entities referenced by a FK. So a "parent" is an EntityRef
foreach (var parent in GetClassParents(table))
{
var entityRefMember = parent.Storage;
writer.WriteLine(writer.GetStatement(
writer.GetAssignmentExpression(
entityRefMember,
writer.GetNewExpression(writer.GetMethodCallExpression(
writer.GetGenericName(TypeExtensions.GetShortName(typeof(EntityRef<>)), parent.Type)
))
)
));
}
writer.WriteLine(writer.GetStatement(writer.GetMethodCallExpression("OnCreated")));
}
}
public RequestBodyTypeGeneratorFactory(GenerationContext context, IMediaTypeSelector mediaTypeSelector)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
_mediaTypeSelector = mediaTypeSelector ?? throw new ArgumentNullException(nameof(mediaTypeSelector));
}
public void TestSetup()
{
Mock<IEngineConfigurationType> type = new Mock<IEngineConfigurationType>();
type.SetupGet(x => x.RegisteredType).Returns(typeof(SimpleUser));
ObjectBuilder builder = new ObjectBuilder(type.Object);
builder.AddAction(
new ObjectPropertySetFromSourceAction(
ReflectionHelper.GetMember<SimpleUser>(x=>x.FirstName) as EngineTypePropertyMember,
new SimpleDataSource(mTestPropertyValue)
));
builder.AddAction(
new ObjectPropertySetFromSourceAction(
ReflectionHelper.GetMember<SimpleUser>(x => x.LastName) as EngineTypePropertyMember,
new SimpleDataSource(mTestPropertyValue)
));
builder.AddAction(
new ObjectPropertySetFromSourceAction(
ReflectionHelper.GetMember<SimpleUser>(x => x.EmailAddress) as EngineTypePropertyMember,
new SimpleDataSource(mTestPropertyValue)
));
Mock<IGenerationConfiguration> builderRepository = new Mock<IGenerationConfiguration>();
builderRepository.Setup(x=>x.GetBuilderForType(typeof(SimpleUser))).Returns(builder);
builderRepository.SetupGet(x => x.RecursionLimit).Returns(10);
mGenerationContext = new GenerationContext(builderRepository.Object);
mMethodGenerator = new ObjectGenerator<SimpleMethodClass>(
mGenerationContext, builder);
mUserGenerator = new ObjectGenerator<SimpleUser>(mGenerationContext, builder);
}
protected override bool ExecuteIsolated()
#endif
{
Log.LogCommandLine($">> [{typeof(GeneratorTask).Namespace}] START");
#if !DEBUG
try
{
#endif
#region Settings Map
Settings.RouteToServiceProjectFolder = RouteToServiceProjectFolder;
Settings.ClientInterfaceName = ClientInterfaceName;
Settings.RegisterName = RegisterName;
Settings.UseValueTask = bool.Parse(UseValueTask ?? "false");
Settings.UseInternalClients = bool.Parse(UseInternalClients ?? "false");
Settings.ClientRouteConstraints = bool.Parse(ClientRouteConstraints ?? "false");
Settings.ErrorOnUnhandledCallback = bool.Parse(ErrorOnUnhandledCallback ?? "false");
Settings.MultipleFiles = bool.Parse(MultipleFiles ?? "false");
Settings.GenerateStaticRoutes = bool.Parse(GenerateStaticRoutes ?? "false");
Settings.RoutesNamespace = RoutesNamespace;
Settings.ClientNamespace = ClientNamespace;
Settings.HubNamespace = HubNamespace;
Settings.AllowedNamespaces = AllowedNamespaces?.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
Settings.ExcludedNamespaces = ExcludedNamespaces?.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
#endregion
Directory.SetCurrentDirectory(CurrentDirectory);
Log.LogCommandLine($"Generating W/ CurrentPath : {CurrentDirectory}");
if (string.IsNullOrWhiteSpace(CurrentDirectory))
{
Log.LogError("One of the settings is not filled out.");
return(false);
}
//Start out by loading all relevent DLLS
if (string.IsNullOrEmpty(Settings.RouteToServiceProjectFolder))
{
Log.LogWarning("Service project folder is not provided");
return(false);
}
Log.LogCommandLine(Settings.RouteToServiceProjectFolder);
//Start out by loading all cs files into memory
var parsedControllers = Directory.EnumerateFiles($"{Environment.CurrentDirectory}/{Settings.RouteToServiceProjectFolder}", "*.cs", SearchOption.AllDirectories)
.Where(x => !x.Contains("/obj/") && !x.Contains("\\obj\\") &&
!x.Contains("/bin/") && !x.Contains("\\bin\\"))
.Select(cs => new HttpControllerCSharpFile(cs))
.ToList();
var parsedHubs = Directory.EnumerateFiles($"{Environment.CurrentDirectory}/{Settings.RouteToServiceProjectFolder}", "*.cs", SearchOption.AllDirectories)
.Where(x => !x.Contains("/obj/") && !x.Contains("\\obj\\") &&
!x.Contains("/bin/") && !x.Contains("\\bin\\"))
.Select(cs => new HubCSharpFile(cs))
.ToList();
var hostFile = Directory.EnumerateFiles($"{Environment.CurrentDirectory}/{Settings.RouteToServiceProjectFolder}", "host.json", SearchOption.AllDirectories)
.Where(x => !x.Contains("/obj/") && !x.Contains("\\obj\\") &&
!x.Contains("/bin/") && !x.Contains("\\bin\\"))
.Select(jn => new HostJsonFile(jn))
.SingleOrDefault();
var parsedFunctions = Directory.EnumerateFiles($"{Environment.CurrentDirectory}/{Settings.RouteToServiceProjectFolder}", "*.cs", SearchOption.AllDirectories)
.Where(x => !x.Contains("/obj/") && !x.Contains("\\obj\\") &&
!x.Contains("/bin/") && !x.Contains("\\bin\\"))
.Select(cs => new FunctionsCSharpFile(cs, hostFile?.Data))
.ToList();
var context = new GenerationContext();
foreach (var file in parsedControllers)
{
context = context.Merge(file.Context);
}
foreach (var file in parsedHubs)
{
context = context.Merge(file.Context);
}
foreach (var file in parsedFunctions)
{
context = context.Merge(file.Context);
}
context.MapRelatedInfo();
context.Validate(Settings.AllowedNamespaces, Settings.ExcludedNamespaces);
ClassWriter.WriteClientsFile(context);
Log.LogCommandLine("Client Generation Successful!");
Log.LogCommandLine($">> [{typeof(GeneratorTask).Namespace}] END");
return(true);
#if !DEBUG
}
catch (Exception ex)
{
Log.LogError(ex.ToString());
return(false);
}
#endif
}
public void GenerateCode(Parameters parameters, Database dbSchema, ISchemaLoader schemaLoader, string filename)
{
ICodeGenerator codeGenerator = FindCodeGenerator(parameters, filename);
if (codeGenerator == null)
throw new ArgumentException("Please specify either a /language or a /code file");
if (string.IsNullOrEmpty(filename))
filename = dbSchema.Class;
if (String.IsNullOrEmpty(Path.GetExtension(filename)))
filename += codeGenerator.Extension;
using (var streamWriter = new StreamWriter(filename))
{
var generationContext = new GenerationContext(parameters, schemaLoader);
codeGenerator.Write(streamWriter, dbSchema, generationContext);
}
}
public ParameterTypeGeneratorFactory(GenerationContext context)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
}
private void WriteDataContextProcedure(CodeWriter writer, Function procedure, GenerationContext context)
{
if (procedure == null || procedure.Name == null)
{
//Logger.Write(Level.Error, "CodeGenStoredProc: Error L33 Invalid storedProcedure object");
writer.WriteCommentLine("error L33 Invalid storedProcedure object");
return;
}
var functionAttribute = NewAttributeDefinition <FunctionAttribute>();
functionAttribute["Name"] = procedure.Name;
functionAttribute["IsComposable"] = procedure.IsComposable;
SpecificationDefinition specifications;
if (procedure.AccessModifierSpecified)
{
specifications = GetSpecificationDefinition(procedure.AccessModifier);
}
else
{
specifications = SpecificationDefinition.Public;
}
if (procedure.ModifierSpecified)
{
specifications |= GetSpecificationDefinition(procedure.Modifier);
}
using (writer.WriteAttribute(functionAttribute))
using (writer.WriteMethod(specifications, GetProcedureName(procedure),
GetProcedureType(procedure), GetProcedureParameters(procedure)))
{
string result = WriteProcedureBodyMethodCall(writer, procedure, context);
WriteProcedureBodyOutParameters(writer, procedure, result, context);
WriteProcedureBodyReturnValue(writer, procedure, result, context);
}
writer.WriteLine();
}
public NoopSecuritySchemeTypeGenerator(ILocatedOpenApiElement <OpenApiSecurityScheme> securitySchemeElement, GenerationContext context,
IAuthenticationNamespace authenticationNamespace, ILogger <NoopSecuritySchemeTypeGenerator> logger)
: base(securitySchemeElement, context, authenticationNamespace)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
//generators
private ContentBase<ObjectId> CreatePost(GenerationContext context)
{
int postIndex = context.TotalEntityCounter % _posts.Count;
int listIteration = context.TotalEntityCounter / _posts.Count;
string title = listIteration + " " + _posts[postIndex].Title;
string url = Translit.RussianToTranslitUrl(title);
DateTime publishTime = DateTime.UtcNow.AddDays(-1).AddMinutes(context.TotalEntityCounter);
UserEssentials user = RandomHelper.PickFromList(_users);
if (_settings.CreatePreviewImages)
{
CreatePostPreviewImage(url, _posts[postIndex].ImageFile);
}
if(_posts[postIndex].ShortContent == null)
{
_posts[postIndex].ShortContent =
ContentMinifier.Minify(_posts[postIndex].FullContent, 250, ContentMinifyMode.ToClosestDot);
}
var post = new Post<ObjectId>()
{
ContentID = ObjectId.GenerateNewId(),
CategoryID = _settings.CategoryID,
AuthorID = user.ID,
AuthorName = user.Name,
Title = title,
Url = url,
CommentsCount = _commentsPerPostCount,
ViewsCount = 0,
FullContent = _posts[postIndex].FullContent,
ShortContent = _posts[postIndex].ShortContent,
HasImage = true,
IsPublished = true,
AddTimeUtc = publishTime,
PublishTimeUtc = publishTime,
IsIndexed = _settings.MarkAsIndexedInSearch
};
post.CreateUpdateNonce();
return post;
}
protected virtual void GenerateModel(ITable table)
{
if (!Options.GenerateModels)
{
return;
}
var tableNamespace = TableNamespace(table);
var modelNamespace = ModelNamespace(table);
var tableClassName = TableClassName(table);
var modelClassName = ModelClassName(table);
var tableClassFullName = TableClassFullName(table);
var tableClass = GenerationContext.FindClass(tableClassName, tableNamespace);
var fileBuilder = ResolveModelFileBuilder(table);
fileBuilder.Namespace(modelNamespace, true, ns =>
{
ns.Class(modelClass =>
{
// set basic info.
modelClass.Partial(true).Name(modelClassName);
if (Options.GenerateModelsInterfaces)
{
var modelInterfaceFullName = ModelInterfaceFullName(table);
modelClass.Inherits(modelInterfaceFullName);
}
Options?.ModelInheritances.ForEach(mi =>
{
modelClass.Inherits(ReplaceMetas(mi, table));
});
MethodBuilder from = null;
MethodBuilder to = null;
if (Options.GenerateModelsFromTo)
{
modelClass.Method(m =>
{
m
.AccessModifier(AccessModifiers.Public)
.Virtual(true)
.ReturnType("void")
.Name("From")
.Parameter(p => p.Type(tableClassFullName).Name("entity"));
from = m;
});
modelClass.Method(m =>
{
m
.AccessModifier(AccessModifiers.Public)
.Virtual(true)
.ReturnType("void")
.Name("To")
.Parameter(p => p.Type(tableClassFullName).Name("entity"));
to = m;
});
}
// set properties.
table.Columns.ForEach(column =>
{
modelClass.Property(columnProperty =>
{
var typeName = GetColumnTypeName(column, ShouldGenerateModelPropertyAsNullable(column)); // Options.GenerateModelPropertyAsNullable);
columnProperty
.Virtual(true)
.Name(column.Name)
.Type(typeName)
.Meta(column);
if (Options.GenerateModelsFromTo)
{
from.RawLine($"{column.Name} = entity.{column.Name}");
bool isPropertyNullable = IsModelPropertyNullable(column); // column.IsNullable || ShouldGenerateModelPropertyAsNullable(column);// Options.GenerateModelPropertyAsNullable;
if (isPropertyNullable && !column.IsNullable)
{
var matchingProp = tableClass.FindByMeta <PropertyBuilder>(column);
var ternary = TernaryBuilder
.Create()
.RawCondition(rc => rc.Condition($"{column.Name} != null"))
.True(RawInlineBuilder.Create($"entity.{column.Name} = ({matchingProp.GetTypeName()}){column.Name}"))
.False(RawInlineBuilder.Create($"entity.{column.Name} = default({matchingProp.GetTypeName()})"));
to.RawLine($"entity.{column.Name} = {ternary.GenerateInline()}");
}
else
{
to.RawLine($"entity.{column.Name} = {column.Name}");
}
}
});
});
});
});
}
public static void Generate(StringBuilder sb, VeldridTypeInfo type, GenerationContext context)
{
// TODO: Ensure the types actually exist, ensure that they're shaders of the appropriate type etc.
// TODO: Ensure vertex shader outputs are compatible with fragment shader inputs
var vshader = context.Types[type.Pipeline.VertexShader];
var fshader = context.Types[type.Pipeline.FragmentShader];
foreach (var input in vshader.Shader.Inputs.Where(x => x.instanceStep != 0))
{
sb.AppendLine($@" static VertexLayoutDescription {LayoutHelperName(input.type)}
{{
get
{{
var layout = {input.type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)}.GetLayout(true);
layout.InstanceStepRate = {input.instanceStep};
return layout;
}}
}}
");
}
sb.Append($@"
public {type.Symbol.Name}() : base(""{vshader.Shader.Filename}"", ""{fshader.Shader.Filename}"",
new[] {{ ");
// e.g. Vertex2DTextured.Layout, SpriteInstanceDataLayout
bool first = true;
foreach (var input in vshader.Shader.Inputs.OrderBy(x => x.slot))
{
if (!first)
{
sb.Append(", ");
}
sb.Append(input.instanceStep == 0
? $"{input.type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)}.GetLayout(true)"
: LayoutHelperName(input.type));
first = false;
}
sb.AppendLine("},");
sb.Append(@" new[] { ");
// e.g. typeof(CommonSet), typeof(SpriteArraySet) }})
first = true;
foreach (var set in vshader.Shader.ResourceSets.Union(fshader.Shader.ResourceSets))
{
if (!first)
{
sb.Append(", ");
}
sb.Append($"typeof({set.type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)})");
first = false;
}
sb.AppendLine(" })");
sb.AppendLine(@" { }");
/* e.g.
* static VertexLayoutDescription SpriteInstanceDataLayout
* {
* get
* {
* var layout = SpriteInstanceData.Layout;
* layout.InstanceStepRate = 1;
* return layout;
* }
* }
*
* public SpritePipeline() : base("SpriteSV.vert", "SpriteSF.frag",
* new[] { Vertex2DTextured.Layout, SpriteInstanceDataLayout },
* new[] { typeof(CommonSet), typeof(SpriteArraySet) })
* {
* }
*/
}
private void GenerateConstructorIL(TypeBuilder typeBuilder, ImplementationRequest request, GenerationContext generationContext, ConstructorBuilder constructor)
{
var ilGenerator = constructor.GetILGenerator();
ilGenerator.Emit(OpCodes.Ldarg_0);
ilGenerator.Emit(OpCodes.Ldarg_1);
ilGenerator.Emit(OpCodes.Stfld, generationContext.RpcExecutionServiceField);
ilGenerator.Emit(OpCodes.Ret);
}
public object Generate(GenerationContext context)
{
return generateFunc(context);
}
public NumberSchemaGenerator(ILocatedOpenApiElement <OpenApiSchema> schemaElement, GenerationContext context,
ITypeGenerator?parent)
: base(schemaElement, context, parent)
{
}
public object Generate(GenerationContext context)
{
return(new DateTime(Constants.Random.Next(1900, 2011), Constants.Random.Next(1, 12), Constants.Random.Next(1, 28)));
}
protected abstract string WriteProcedureBodyMethodCall(CodeWriter writer, DbLinq.Schema.Dbml.Function procedure, GenerationContext context);
