private Task InitGeneratorSettings(GeneratorSettings settings)
{
IServerSettings serverSettings = GrainFactory.GetGrain <IServerSettings>(0);
// TODO move server settings to generator settings
return(Task.CompletedTask);
}
public ClassFile GenerateClass(
GeneratorSettings settings,
ParsedDefinitionList definitionList,
string nameSpace,
string className,
bool addVerbToClassName,
ParsedVerb verb,
List <ParsedItem> items)
{
Clear();
TabSpaces = settings.TabSpaces;
className = className + (addVerbToClassName ? verb.Name.Titleize() : "");
WriteLines(definitionList.Lines);
WriteLine();
WriteNamespace(nameSpace);
WriteSummaryComment(definitionList.Description);
if (verb != null)
{
WriteAttribute("Verb", (null, verb.Name), ("HelpText", verb.DefinitionItem.HelpText ?? ""));
}
WriteClass(className);
GenerateProperties(items);
ClosingBracket();
ClosingBracket();
return(new ClassFile()
{
Namespace = nameSpace,
ClassName = className,
FileName = className + ".cs",
Code = Code
});
}
public static bool GenerateCrossAccess(GeneratorSettings settings, SchemaModel schema, SchemaModel remoteSchema)
{
//set the right target namespace for usings
settings.Namespace = settings.OutputPath;
if (!settings.Namespace.StartsWith("Xbim."))
{
settings.Namespace = "Xbim." + settings.Namespace;
}
settings.CrossAccessNamespace = settings.CrossAccessProjectPath + "." + settings.SchemaInterfacesNamespace;
var entityMatches = EntityDefinitionMatch.GetMatches(schema, remoteSchema).ToList();
var templates =
entityMatches.Where(m => m.Target != null)
.Select(m => new EntityInterfaceImplementation(settings, m, entityMatches) as ICodeTemplate);
var selectTemplates =
GetSelectsToImplement(schema, remoteSchema, entityMatches)
.Select(s => new SelectInterfaceImplementation(settings, s.Item1, s.Item2));
var infrastructureTemplates = new ICodeTemplate[] { new CreatorTemplate(settings, entityMatches) };
var toProcess = templates.Concat(selectTemplates); //.Concat(infrastructureTemplates).ToList();
//toProcess.ForEach(t => ProcessTemplate(t, settings.Namespace));
Parallel.ForEach(toProcess, t => ProcessTemplate(t, settings.Namespace));
return(true);
}
public string GetSwagger(string type)
{
var httpRequest = HttpContext?.Request;
var generatorSettings = new GeneratorSettings(httpRequest)
{
DefaultUrlTemplate = "api/[controller]/{id?}",
IgnoreObsolete = true,
Info = new Info()
{
Title = "QSwag Test API", Version = "1.0"
},
XmlDocPath = Path.ChangeExtension(Assembly.GetEntryAssembly().Location, "xml"),
SecurityDefinitions = new Dictionary <string, SecurityDefinition>()
{
{
"jwt_token",
new SecurityDefinition("Authorization", SecuritySchemeType.ApiKey)
{
In = Location.Header
}
}
},
JsonSchemaLicense = Licenses.NewtonSoft
};
generatorSettings.Security.Add(new SecurityRequirement("jwt_token"));
var typeFromString = GetTypeFromString(type);
if (typeFromString == null)
{
return(string.Empty);
}
return(WebApiToSwagger
.GenerateForController(typeFromString, generatorSettings, nameof(GetSwagger)));
}
public void CountryTest()
{
GeneratorSettings settings = new GeneratorSettings
{
Language = Languages.English,
Country = true
};
PersonGenerator.PersonGenerator personGenerator = new PersonGenerator.PersonGenerator(settings);
List <Person> people = personGenerator.Generate(100);
bool countryCorrect = true;
foreach (Person person in people)
{
countryCorrect = !string.IsNullOrEmpty(person.Country);
if (!countryCorrect)
{
break;
}
person.Print();
}
Assert.AreEqual(countryCorrect, true);
}
public void AgeTest()
{
Random random = new Random();
int minAge = random.Next(0, 50);
int maxAge = random.Next(50, 101);
GeneratorSettings settings = new GeneratorSettings
{
Age = true,
MinAge = minAge,
MaxAge = maxAge
};
PersonGenerator.PersonGenerator personGenerator = new PersonGenerator.PersonGenerator(settings);
List <Person> people = personGenerator.Generate(100);
bool ageCorrect = true;
foreach (Person person in people)
{
ageCorrect = person.Age.Value >= minAge && person.Age.Value <= maxAge;
if (!ageCorrect)
{
break;
}
}
Assert.AreEqual(ageCorrect, true);
}
private static void SetSettingsFromFlags(List <string> flagsAsStrings, GeneratorSettings settings)
{
foreach (var flagAsString in flagsAsStrings)
{
var flag = (GeneratorSettingFlag)System.Enum.Parse(typeof(GeneratorSettingFlag), flagAsString, true);
if (flag == GeneratorSettingFlag.NoIndexes)
{
settings.NoIndexes = true;
}
if (flag == GeneratorSettingFlag.NoUniqueConstraints)
{
settings.NoUniqueConstraints = true;
}
if (flag == GeneratorSettingFlag.NoForeignKeys)
{
settings.NoForeignKeys = true;
}
if (flag == GeneratorSettingFlag.ShouldCommentOutColumnsWithFkReferencedTables)
{
settings.ShouldCommentOutColumnsWithFkReferencedTables = true;
}
if (flag == GeneratorSettingFlag.ShouldCommentOutFkReferences)
{
settings.ShouldCommentOutFkReferences = true;
}
}
}
private void ShowVisualization()
{
var input = Program.GetMapDescriptionsSet(new Vector2Int(1, 1), true, new List <int>()
{
2, 4, 6
}, false)[4];
var layoutGenerator = new DungeonGenerator <int>(input.MapDescription, input.Configuration);
layoutGenerator.InjectRandomGenerator(new Random(0));
var settings = new GeneratorSettings
{
LayoutGenerator = layoutGenerator,
NumberOfLayouts = 10,
ShowPartialValidLayouts = false,
ShowPartialValidLayoutsTime = 500,
ShowPerturbedLayouts = true,
ShowPerturbedLayoutsTime = 1000,
ShowFinalLayouts = true,
};
Application.Run(new GeneratorWindow(settings));
}
private static void BuildApplicationOctetStreamExtensionMethodBody(GeneratorSettings settings, StringBuilder builder, RestEaseInterfaceMethodDetails method)
{
builder.AppendLine(" var content = new MultipartFormDataContent();");
builder.AppendLine();
var formUrlEncodedContentList = new List <string>();
foreach (var parameter in method.ExtensionMethodParameters)
{
switch (parameter.SchemaType)
{
case SchemaType.String:
switch (parameter.SchemaFormat)
{
case SchemaFormat.Binary:
case SchemaFormat.Byte:
string identifierName = $"{parameter.Identifier}Content";
switch (settings.ApplicationOctetStreamType)
{
case ApplicationOctetStreamType.Stream:
builder.AppendLine($" var {identifierName} = new StreamContent({parameter.Identifier});");
break;
default:
builder.AppendLine($" var {identifierName} = new ByteArrayContent({parameter.Identifier});");
break;
}
builder.AppendLine($" content.Add({identifierName});");
builder.AppendLine();
break;
default:
formUrlEncodedContentList.Add(parameter.Identifier);
break;
}
break;
default:
formUrlEncodedContentList.Add(parameter.Identifier);
break;
}
}
if (formUrlEncodedContentList.Any())
{
builder.AppendLine(" var formUrlEncodedContent = new FormUrlEncodedContent(new[] {");
foreach (var formUrlEncodedContent in formUrlEncodedContentList)
{
string comma = formUrlEncodedContent != formUrlEncodedContentList.Last() ? "," : string.Empty;
builder.AppendLine(
$" new KeyValuePair<string, string>(\"{formUrlEncodedContent}\", {formUrlEncodedContent}.ToString()){comma}");
}
builder.AppendLine(" });");
builder.AppendLine();
builder.AppendLine(" content.Add(formUrlEncodedContent);");
}
}
public SelectInterfaceImplementation(GeneratorSettings settings, SelectType source, SelectType target)
{
_source = source;
_target = target;
_helper = new NamedTypeHelper(source, settings);
Settings = settings;
}
public SqlTableTypeGenerator(GeneratorSettings generatorSettings, TSqlObject table, bool preview = false)
: base(generatorSettings, table: table, previewMode: preview)
{
_settings = TableSettings?.SqlTableTypeSettings;
//TODO to be implemented
// this.DoNotIncludeColumns = doNotIncludeColumns ?? this.DoNotIncludeColumns;
}
public GeneratorSettings Generate(GeneratorSettings settings)
{
if (!this.PreCheckSimple(settings))
{
return(null);
}
this.SetWorkHours(ref settings);
for (int i = 0; i < settings.Works.Count; i++)
{
var work = settings.Works[i];
var persons = settings.Persons;
this.GenerateToWork(ref work, ref persons, settings.MaxWorkHour);
settings.Works[i] = work;
settings.Persons = persons;
}
settings.HasGeneratedCsomor = true;
settings.LastGeneration = DateTime.Now;
return(settings);
}
/// <summary>
/// Check hours.
/// All hours is correct.
/// </summary>
/// <param name="settings">Generator settings</param>
/// <returns>Valid or not</returns>
private bool CheckHours(GeneratorSettings settings)
{
// Start
var start = settings.Start;
while (start < settings.Finish)
{
// Count of works
int works = settings.Works.Count(x =>
x.Tables.FirstOrDefault(y => this.CompareDates(start, y.Date))?.IsActive ?? false);
// Count of persons
int persons = settings.Persons.Count(x =>
x.Tables.FirstOrDefault(y => this.CompareDates(start, y.Date))?.IsAvailable ?? false);
// Work number has to be less thank works
if (works > persons)
{
throw new MessageException($"There are not enough person in hour {start.Month.ToString().PadLeft(2, '0')}-{start.Day.ToString().PadLeft(2, '0')}-{start.Hour.ToString().PadLeft(2, '0')}.");
}
start = start.AddHours(1);
}
return(true);
}
static void Main(string[] args)
{
var watch = Stopwatch.StartNew();
//set working directory
Environment.CurrentDirectory = @"c:\Users\Martin\Source\Repos\XbimCobieExpress";
var cobie = SchemaModel.Load(File.ReadAllText("COBieExpress.exp"), "COBIE");
//Change names to prevent name clashes
foreach (var entity in cobie.Get <EntityDefinition>())
{
entity.Name = "Cobie" + entity.Name;
}
var settings = new GeneratorSettings
{
OutputPath = "Xbim.CobieExpress",
};
Generator.GenerateSchema(settings, cobie);
Console.WriteLine(@"COBieExpress generated");
watch.Stop();
Console.WriteLine(@"Finished in {0}s.", watch.ElapsedMilliseconds / 1000);
Console.Beep(440, 500);
Console.ReadKey();
}
private static GeneratorContext CreateGeneratorContext(Context context, string patternFileName)
{
var documenterSettings = Program.Configuration.GetSection("Documenter").Get <DocumenterSettings>();
var generatorSetting = new GeneratorSettings {
WorkingDirectory = documenterSettings.WorkingDirectory
};
ITableCustomizer customizer = null;
if (patternFileName != null)
{
customizer = PatternMatchingTableCustomizerFromPatterns.FromCsv(patternFileName, documenterSettings);
}
customizer ??= new EmptyTableCustomizer();
var generatorContext = new GeneratorContext
{
GeneratorSettings = generatorSetting,
Settings = context.Settings,
Logger = context.Logger,
Customizer = customizer
};
return(generatorContext);
}
protected async Task GenerateOre(IWorld world, ChunkWorldPos chunkWorldPos, GeneratorSettings settings)
{
var oreGenerator = GrainFactory.GetGrain <IMinableGenerator>(0);
await oreGenerator.Generate(world, chunkWorldPos, BlockStates.Dirt(), settings.DirtCount, settings.DirtSize, settings.DirtMinHeight, settings.DirtMaxHeight);
await oreGenerator.Generate(world, chunkWorldPos, BlockStates.Gravel(), settings.GravelCount, settings.GravelSize, settings.GravelMinHeight, settings.GravelMaxHeight);
await oreGenerator.Generate(world, chunkWorldPos, BlockStates.Granite(), settings.GraniteCount, settings.GraniteSize, settings.GraniteMinHeight, settings.GraniteMaxHeight);
await oreGenerator.Generate(world, chunkWorldPos, BlockStates.Diorite(), settings.DioriteCount, settings.DioriteSize, settings.DioriteMinHeight, settings.DioriteMaxHeight);
await oreGenerator.Generate(world, chunkWorldPos, BlockStates.Andesite(), settings.AndesiteCount, settings.AndesiteSize, settings.AndesiteMinHeight, settings.AndesiteMaxHeight);
await oreGenerator.Generate(world, chunkWorldPos, BlockStates.CoalOre(), settings.CoalCount, settings.CoalSize, settings.CoalMinHeight, settings.CoalMaxHeight);
await oreGenerator.Generate(world, chunkWorldPos, BlockStates.IronOre(), settings.IronCount, settings.IronSize, settings.IronMinHeight, settings.IronMaxHeight);
await oreGenerator.Generate(world, chunkWorldPos, BlockStates.GoldOre(), settings.GoldCount, settings.GoldSize, settings.GoldMinHeight, settings.GoldMaxHeight);
await oreGenerator.Generate(world, chunkWorldPos, BlockStates.DiamondOre(), settings.DiamondCount, settings.DiamondSize, settings.DiamondMinHeight, settings.DiamondMaxHeight);
await oreGenerator.Generate(world, chunkWorldPos, BlockStates.RedstoneOre(), settings.RedstoneCount, settings.RedstoneSize, settings.RedstoneMinHeight, settings.RedstoneMaxHeight);
await oreGenerator.Generate(world, chunkWorldPos, BlockStates.LapisLazuliOre(), settings.LapisCount, settings.LapisSize, settings.LapisCenterHeight - settings.LapisSpread, settings.LapisCenterHeight + settings.LapisSpread);
}
public void Generate(
ParsedDefinitionList definitionList,
GeneratorSettings settings,
IConsoleWriter consoleWriter)
{
var cliClasses = new List <ClassFile>();
foreach (var definition in definitionList.Definitions)
{
var verbs = definition.ParsedItems.OfType <ParsedVerb>().ToList();
var notVerbs = definition.ParsedItems.Where(e => !(e is ParsedVerb)).ToList();
var nameSpace = definition.Definition.Namespace ?? definitionList.Namespace;
var className = definition.Definition.ClassName ?? "CliOptions";
if (verbs.Count == 0)
{
verbs.Add(null);
}
// Multiple classes. One class for each verb
foreach (var verb in verbs)
{
cliClasses.Add(OptionsClassGenerator.GenerateClass(settings, definitionList, nameSpace, className, verbs.Count > 1, verb, notVerbs));
}
}
cliClasses.Add(ProgramClassGenerator.GenerateClass(settings, definitionList, cliClasses));
WriteFiles(cliClasses, settings, consoleWriter);
}
private void SearchPathAndAdd(AppProjectGenerator appgen, INodeGenSettings ngs, IvPluginGenerator gen)
{
foreach (var t in gen.GetListNodeGenerationSettings())
{
string modelPath = this.ModelPath;
var searchPattern = t.SearchPathInModel;
var is_found = SearchInModelPathByPattern(modelPath, searchPattern);
if (is_found)
{
GeneratorSettings gs = new GeneratorSettings(this);
gs.NodeSettingsVmGuid = t.Guid;
gs.AppGeneratorGuid = appgen.Guid;
_logger.LogTrace("Adding Node Settings. {Path} NodeSettingsVmGuid={NodeSettingsVmGuid} Name={Name}".CallerInfo(), t.SearchPathInModel, gs.NodeSettingsVmGuid, appgen.Name);
#if DEBUG
foreach (var ttt in ngs.ListGeneratorsSettings)
{
if (ttt.AppGeneratorGuid == appgen.Guid)
{
throw new Exception();
}
}
#endif
ngs.ListGeneratorsSettings.Add(gs);
gs.SettingsVm = t.GetAppGenerationNodeSettingsVm(gs.Settings);
break;
}
}
}
public void WriteFiles(
List <ClassFile> cliClasses,
GeneratorSettings settings,
IConsoleWriter consoleWriter)
{
foreach (var item in cliClasses)
{
if (item == null)
{
if (settings.Verbose)
{
consoleWriter.WriteWarning($"Null generated class.");
}
continue;
}
var outputFileName = item.FileName;
if (!string.IsNullOrEmpty(settings.OutputPath))
{
outputFileName = Path.Combine(settings.OutputPath, outputFileName);
}
if (!settings.OverwriteFiles && File.Exists(outputFileName))
{
consoleWriter.WriteError($"ERROR: Cannot overwrite existing file \"{outputFileName}\"");
continue;
}
if (settings.Verbose)
{
consoleWriter.WriteLine($"Writing class {item.ClassName} file \"{outputFileName}\"");
}
File.WriteAllText(outputFileName, item.Code);
}
}
public void NameTest()
{
GeneratorSettings settings = new GeneratorSettings
{
Language = Languages.English,
FirstName = true,
MiddleName = true,
LastName = true
};
PersonGenerator.PersonGenerator personGenerator = new PersonGenerator.PersonGenerator(settings);
List <Person> people = personGenerator.Generate(100);
bool nameCorrect = true;
foreach (Person person in people)
{
nameCorrect = !string.IsNullOrEmpty(person.FirstName) &&
!string.IsNullOrEmpty(person.MiddleName) &&
!string.IsNullOrEmpty(person.LastName);
if (!nameCorrect)
{
break;
}
}
Assert.AreEqual(nameCorrect, true);
}
private void OnMessagesCollected(MessageCollection <ModifyModel, ModelVersionCreated> set)
{
set.MarkAsConsumed(set.Message1);
if (set.Message1.Modification.Target is not GeneratorSettings generatorSettings)
{
return;
}
GeneratorSettings updatedModel;
switch (set.Message1.Modification.Property)
{
case GeneratorSettingsPackageNamespaceProperty _:
updatedModel = new GeneratorSettings(set.Message1.Modification.NewValue.AssertTypeOf <string>(),
generatorSettings.GenerateAutofacModule);
break;
case GeneratorSettingsGenerateAutofacProperty _:
updatedModel = new GeneratorSettings(generatorSettings.PackageNamespace,
set.Message1.Modification.NewValue.AssertTypeOf <bool>());
break;
default:
throw new InvalidOperationException($"Property {set.Message1.Modification.Property} unknown for agent model.");
}
CommunityModel updatedCommunity = new(updatedModel,
set.Message2.Model.Agents,
set.Message2.Model.Messages);
OnMessage(new ModificationResult(updatedCommunity, set));
}
public override void Init(MyObjectBuilder_SessionComponent sessionComponent)
{
InitNet();
if (!Sync.IsServer || !SettingsSession.Static.Settings.Enable || MySession.Static.Settings.WorldSizeKm > 0)
{
return;
}
MyObjectBuilder_StarSystem b = GetConfig();
m_objects = b.SystemObjects;
m_seed = MySession.Static.Settings.ProceduralSeed + MyRandom.Instance.CreateRandomSeed();
m_settings = SettingsSession.Static.Settings.GeneratorSettings;
//FilterDefinitions();
if (b == null || m_objects == null || m_objects.Count == 0)
{
GenerateSystem();
}
MySession.Static.OnReady += delegate
{
if (SettingsSession.Static.Settings.GeneratorSettings.BeltSettings.ShowBeltGPS)
{
AddBeltsGpss();
}
};
}
public void EnsureFilesAreNotGeneratedWhenDeprecated()
{
string projectFolder = Environment.CurrentDirectory + "\\..\\..\\..\\";
GeneratorSettings settings = new GeneratorSettings(projectFolder);
GeneratorResult result = GenerateModel <MockModelWithDeprecate>(settings);
// The person entity is deprecated so it should be excluded in the entity result
bool exist = result.EntityResult.Select(x => x.Key).SingleOrDefault(x => x == "PersonEntity") != null;
Assert.IsFalse(exist);
string entityPath = Path.Combine(Path.Combine(projectFolder, settings.EntitiesFolder), "PersonEntity.cs");
Assert.IsFalse(File.Exists(entityPath));
string basePath = Path.Combine(Path.Combine(projectFolder, settings.EntitiesFolder), "BaseEntityGenerator.cs");
string baseNodePath = Path.Combine(Path.Combine(projectFolder, settings.NodesFolder), "BaseEntityGeneratorNode.cs");
if (File.Exists(basePath))
{
File.Delete(basePath);
}
if (File.Exists(baseNodePath))
{
File.Delete(baseNodePath);
}
}
public static Bomb Generate(int modules, GeneratorSettings settings)
{
Bomb result = new Bomb(modules);
result.BombInfo = new BombInfo();
result.BombInfo.Init();
for (int i = 0; i < modules; i++)
{
if (RandomUtil.Double() <= settings.VanillaPercentage)
{
result.Modules[i] = ModulePools.Vanilla.Random();
}
else
{
result.Modules[i] = ModulePools.Mods.Random();
}
result.Modules[i].BombInfo = result.BombInfo;
result.Modules[i].ModuleID = i + 1;
}
for (int i = 0; i < modules; i++)
{
result.Modules[i].Init();
}
return(result);
}
public BiomeHill(BiomeHillType type, BiomeProperties properties, GeneratorSettings genSettings)
: base(properties, genSettings)
{
_type = type;
if (type == BiomeHillType.Normal)
{
_name = "extreme_hills";
_biomeId = BiomeId.ExtremeHills;
_baseHeight = 1.0F;
_heightVariation = 0.5F;
_temperature = 0.2F;
_rainfall = 0.3F;
_enableRain = true;
}
else
{
_name = "extreme_hills";
_biomeId = BiomeId.ExtremeHills;
_baseHeight = 1.0F;
_heightVariation = 0.5F;
_temperature = 0.2F;
_rainfall = 0.3F;
_enableRain = true;
}
}
public BiomeTaiga(BiomeTaigaType type, BiomeProperties properties, GeneratorSettings genSettings)
: base(properties, genSettings)
{
_name = "taiga";
_biomeId = BiomeId.Taiga;
_baseHeight = 0.2F;
_heightVariation = 0.2F;
_temperature = 0.25F;
_treesPerChunk = 10;
_grassPerChunk = 2;
_temperature = 0.7F;
_rainfall = 0.8F;
_enableRain = true;
_type = type;
if (type != BiomeTaigaType.Mega && type != BiomeTaigaType.MegaSpruce)
{
_grassPerChunk = 1;
_mushroomsPerChunk = 1;
}
else
{
_grassPerChunk = 7;
_deadBushPerChunk = 1;
_mushroomsPerChunk = 3;
}
}
public Form1()
{
InitializeComponent();
_generatorSettings = new GeneratorSettings();
_dataTypeGenerator = new DataTypeGenerator();
_generateFieldControls = new List <GenerateFieldControl>();
}
public async Task Populate(IWorld world, int x, int z, GeneratorSettings settings)
{
var chunkColumnKey = world.MakeAddressByPartitionKey(new ChunkWorldPos {
X = x, Z = z
});
ChunkColumnCompactStorage chunkColumn = await GrainFactory.GetGrain <IChunkColumn>(chunkColumnKey).GetStateUnsafe();
Biome chunkBiome = Biome.GetBiome(chunkColumn.Biomes[7 * 16 + 7], settings);
if (chunkBiome.GetBiomeId() == BiomeId.Plains)
{
var decorator = GrainFactory.GetGrain <IBiomePlainsDecorator>((long)BiomeId.Plains);
await decorator.Decorate(world, new ChunkWorldPos(x, z), settings);
// decorator.SpawnMob(world, chunk, new ChunkWorldPos(x, z), new BlockWorldPos { X = blockX, Z = blockZ });
}
else if (chunkBiome.GetBiomeId() == BiomeId.Forest)
{
var decorator = GrainFactory.GetGrain <IBiomeForestDecorator>((long)BiomeId.Forest);
await decorator.Decorate(world, new ChunkWorldPos(x, z), settings);
}
else if (chunkBiome.GetBiomeId() == BiomeId.Taiga)
{
var decorator = GrainFactory.GetGrain <IBiomeTaigaDecorator>((long)BiomeId.Taiga);
await decorator.Decorate(world, new ChunkWorldPos(x, z), settings);
}
else if (chunkBiome.GetBiomeId() == BiomeId.Savanna)
{
var decorator = GrainFactory.GetGrain <IBiomeSavannaDecorator>((long)BiomeId.Savanna);
await decorator.Decorate(world, new ChunkWorldPos(x, z), settings);
}
}
public void GetAndCreateTest()
{
GeneratorSettings generatorSettings = new GeneratorSettings();
UniqueNamer uniqueNamer = new UniqueNamer();
TemplateContent templateContent = new TemplateContent(generatorSettings, uniqueNamer);
AbpDbContentTemplate abpDbContentTemplate = new AbpDbContentTemplate(templateContent);
MySQLSchemaProvider mySqlSchemaProvider = new MySQLSchemaProvider();
const string mysqlConn = "Server=127.0.0.1;Database=esms;Uid=root;Pwd=123qwe!@#;";
SchemaSelector schemaSelector = new SchemaSelector(mySqlSchemaProvider, mysqlConn);
foreach (TableSchema tableSchema in schemaSelector.Tables)
{
foreach (DataObjectBase columnSchema in tableSchema.Columns)
{
Console.WriteLine(columnSchema.FullName);
}
}
//EntityContext<AbpEntity, AbpEntityProperty> entityContext = abpDbContentTemplate.GetAndCreate(schemaSelector);
//Entity<AbpEntityProperty> entity = entityContext.Entities.First(t => t.ClassName == "SysUser");
//foreach (Relationship relationship in entity.Relationships.Where(t=>t.ThisEntity.Contains("SysUser")&&t.ThisPropertyName=="LastRole"))
//{
// Console.WriteLine(relationship.JoinTable);
//}
}
/// <summary>
/// Get all of the code generators for a repository IE: (Graph, or Project)
/// </summary>
/// <param name="settings">Obsolete pass null</param>
/// <param name="project">Project or graph</param>
/// <param name="generator"></param>
/// <param name="diagramItemGenerator"></param>
/// <param name="includeDisabled"></param>
/// <returns></returns>
private static IEnumerable <OutputGenerator> GetCodeGeneratorsForNodes(GeneratorSettings settings,
IRepository project,
DesignerGeneratorFactory generator, DesignerGeneratorFactory diagramItemGenerator,
bool includeDisabled = false)
{
yield break;
// TODO 2.0 IMPORANT: Figure out code generators
//var diagrams = project.AllOf<IGraphData>();
//foreach (var diagram in diagrams)
//{
// if (diagram.Precompiled) continue;
// if (diagram.Settings.CodeGenDisabled && !includeDisabled) continue;
// var items = diagram.AllGraphItems.OfType<IDiagramNodeItem>().Where(p => p.GetType() == generator.DiagramItemType);
// foreach (var item in items)
// {
// if (item.Precompiled) continue;
// var codeGenerators = generator.GetGenerators(settings, null, project, item);
// foreach (var codeGenerator in codeGenerators)
// {
// // TODO had to remove this?
// //if (!codeGenerator.IsEnabled(project)) continue;
// codeGenerator.AssetDirectory = diagram.Project.SystemDirectory;
// codeGenerator.Settings = settings;
// if (codeGenerator.ObjectData == null)
// codeGenerator.ObjectData = item;
// codeGenerator.GeneratorFor = diagramItemGenerator.DiagramItemType;
// yield return codeGenerator;
// }
// }
//}
}
public void GetAndCreateTest()
{
GeneratorSettings generatorSettings = new GeneratorSettings();
UniqueNamer uniqueNamer = new UniqueNamer();
TemplateContent templateContent = new TemplateContent(generatorSettings, uniqueNamer);
AbpDbContentTemplate abpDbContentTemplate = new AbpDbContentTemplate(templateContent);
MySQLSchemaProvider mySqlSchemaProvider = new MySQLSchemaProvider();
const string mysqlConn = "Server=127.0.0.1;Database=esms;Uid=root;Pwd=123qwe!@#;";
SchemaSelector schemaSelector = new SchemaSelector(mySqlSchemaProvider, mysqlConn);
foreach (TableSchema tableSchema in schemaSelector.Tables)
{
foreach (DataObjectBase columnSchema in tableSchema.Columns)
{
Console.WriteLine(columnSchema.FullName);
}
}
//EntityContext<AbpEntity, AbpEntityProperty> entityContext = abpDbContentTemplate.GetAndCreate(schemaSelector);
//Entity<AbpEntityProperty> entity = entityContext.Entities.First(t => t.ClassName == "SysUser");
//foreach (Relationship relationship in entity.Relationships.Where(t=>t.ThisEntity.Contains("SysUser")&&t.ThisPropertyName=="LastRole"))
//{
// Console.WriteLine(relationship.JoinTable);
//}
}
