public override async Task <IGenesisExecutionResult> Execute(GenesisContext genesis, string[] args) { var result = new OutputGenesisExecutionResult(); if (!Directory.Exists(Config.OutputPath)) //TODO: Worry about the output path in the OutputGenerator base { Directory.CreateDirectory(Config.OutputPath); } foreach (var obj in genesis.Objects) { await ExecuteGraph(obj); } var outPath = Path.Combine(Config.OutputPath, "Mapper.cs"); var output = Template.Raw .Replace("~MAPPING_CODE~", string.Join(Environment.NewLine, _lines)) .Replace(Tokens.DepsModelNamespace, Config.ModelNamespace) .Replace(Tokens.DepsDtoNamespace, Config.DtoNamespace) .Replace(Tokens.DepsNamespace, Config.DepsNamespace) .Replace(Tokens.Namespace, Config.Namespace); File.WriteAllText(outPath, output); result.Success = true; return(result); }
public override async Task <IGenesisExecutionResult> Execute(GenesisContext genesis, string[] args) { var result = new BlankGenesisExecutionResult(); var alc = new AssemblyLoadContext("DotNetAssembly", true); using var stream = File.OpenRead(Config.AssemblyPath); var asm = alc.LoadFromStream(stream); if (Config.OnlyGenesisDecorations) { foreach (var t in asm.DefinedTypes.Where(w => // pull objects with GenesisObject attribute w.CustomAttributes.SingleOrDefault(ca => ca.AttributeType == typeof(GenesisObjectAttribute)) != null)) { InsertGraphFromType(genesis, t); } } else // use all public objects { foreach (var t in asm.DefinedTypes) { InsertGraphFromType(genesis, t); } } return(await Task.FromResult(result)); }
public override async Task <ITaskResult> Execute(GenesisContext genesis, string[] args) { Text.DarkYellowLine("Paused... press the any key"); Console.ReadKey(); return(await Task.FromResult(new BlankTaskResult())); }
public static void InitCompanyData(GenesisContext context) { try { //hejehj var adr = new Address("Nejlikegatan 3", "70353", "Örebro"); var comp1 = context.Companies.Find("o1"); if (comp1 != null) { context.Companies.Remove(comp1); context.SaveChanges(); } var comp = new Company("o1", "n1", "*****@*****.**", "p1", adr); var dep1 = new Department("Olaigatan", adr, "phone1"); dep1.AddOpenHoursOfDay(DayOfWeek.Monday, TimeSpan.FromHours(8), TimeSpan.FromHours(16)); dep1.AddOpenHoursOfDay(DayOfWeek.Tuesday, TimeSpan.FromHours(8), TimeSpan.FromHours(16)); dep1.AddOpenHoursOfDay(DayOfWeek.Wednesday, TimeSpan.FromHours(8), TimeSpan.FromHours(16)); dep1.AddOpenHoursOfDay(DayOfWeek.Friday, TimeSpan.FromHours(8), TimeSpan.FromHours(16)); dep1.AddOpenHoursOfDay(DayOfWeek.Saturday, TimeSpan.FromHours(10), TimeSpan.FromHours(15)); dep1.AddExceptionDay(new DateTime(2018, 2, 24)); dep1.AddExceptionDay(new DateTime(2018, 2, 28)); comp.Departments.Add(dep1); context.Companies.Add(comp); context.SaveChanges(); } catch (Exception ex) { } }
public override async Task <IGenesisExecutionResult> Execute(GenesisContext genesis, string[] args) { return(await Task.FromResult(new OutputGenesisExecutionResult() { Success = true, Message = "Bad command or file name" })); //heh }
public override async Task <IGenesisExecutionResult> Execute(GenesisContext genesis, string[] args) { await CommandLoader.InitAsync(args); Text.Line(); Text.Cyan("Genesis"); Text.GrayLine($" {Program.GetVersionDisplayString()}"); Text.Line(); foreach (var cmd in CommandLoader.Commands) { if (cmd.Name == string.Empty) //default command leaves an empty line otherwise { continue; } Text.Green($"\t{cmd.Name}"); Text.WhiteLine($"\t{cmd.Description}"); } Text.Line(); return(await Task.FromResult(new BlankGenesisExecutionResult() { Success = true, Message = "" })); }
public override async Task <ITaskResult> Execute(GenesisContext genesis, string[] args) { var result = new BlankTaskResult() { Success = true, Message = "" }; Text.Line(); Text.YellowLine("Scanning for Inputs:"); await InputManager.InitializePopulatorsAsync(true); Text.Line(); Text.YellowLine("Scanning for Outputs:"); await OutputManager.InitializeGeneratorsAsync(true); Text.Line(); Console.ForegroundColor = (InputManager.Inputs.Count > 0) ? ConsoleColor.Green : ConsoleColor.Yellow; Console.Write($@"{InputManager.Inputs.Count}"); Console.ResetColor(); Console.WriteLine($" Populator(s)"); Console.ForegroundColor = (OutputManager.Outputs.Count > 0) ? ConsoleColor.Green : ConsoleColor.Yellow; Console.Write($"{OutputManager.Outputs.Count}"); Console.ResetColor(); Console.WriteLine(" Generator(s)"); genesis.ScanCount++; return(await Task.FromResult(result)); }
private static void CreateObjectMethodGraphs(GenesisContext genesis, TypeInfo cls, ObjectGraph obj) { var events = new List <string>(); foreach (var m in cls.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)) { if (m.Name.StartsWith("get_") || m.Name.StartsWith("set_")) { continue; //already did property accessors } if (m.Name.StartsWith("add_") || m.Name.StartsWith("remove_")) { var name = m.Name.Split('_')[1]; //just get the event Name if (!events.Contains(name)) { events.Add(name); } } Debug.WriteLine($@"Method:{(_nullableRegex.IsMatch(m.Name) ? _nullableRegex.Match(m.Name).Value : m.Name)}"); var methodGraph = new MethodGraph { Name = _nullableRegex.IsMatch(m.Name) ? _nullableRegex.Match(m.Name).Value : m.Name, MethodVisibility = MethodVisibilities.Public, ReturnDataType = m.ReturnType, ReturnTypeFormattedName = m.ReturnType.GetFormattedName(), HasGenericParams = m.ContainsGenericParameters, IsGeneric = m.IsGenericMethod, FormattedGenericArguments = m.GetGenericArguments().ToFormattedNames(), }; foreach (var par in m.GetParameters().OrderBy(o => o.Position)) { var mp = new ParameterGraph { DataType = par.ParameterType, DataTypeFormattedName = par.ParameterType.GetFormattedName(), DisplayName = par.ParameterType.GetDisplayName(), Name = par.Name, IsOut = par.IsOut, IsIn = par.IsIn, IsOptional = par.IsOptional, Position = par.Position, IsGeneric = par.ParameterType.IsGenericType, IsGenericMethodParameter = par.ParameterType.IsGenericMethodParameter, GenericArgumentFormattedTypeNames = par.ParameterType.GetGenericArguments().ToFormattedNames(), }; methodGraph.Parameters.Add(mp); } obj.Methods.Add(methodGraph); Text.GrayLine( $"\tMethod: {m.Name}, Return: {methodGraph.ReturnTypeFormattedName}, Visibility: {(m.IsPublic ? "public" : m.IsPrivate ? "private" : "protected")}"); } genesis.Objects.Add(obj); }
public override async Task <ITaskResult> Execute(GenesisContext genesis, string[] args) { var result = new InputTaskResult(); if (args.Length == 1 || HelpWasRequested(args)) //just 'gen' or 'gen --help,-?' { Console.WriteLine("Usage:"); Console.WriteLine($"\t{Name} <Populator>\t\t\tSet the current populator to the type provided."); Console.ForegroundColor = ConsoleColor.Cyan; Console.WriteLine($"\t'{Name} PopulatorName'"); Console.ResetColor(); Console.WriteLine(); if (InputManager.Inputs.Count == 0) //NO Inputs Found { Console.ForegroundColor = ConsoleColor.Yellow; Console.Write("There are no populators discovered yet. Run a '"); Console.ForegroundColor = ConsoleColor.Green; Console.Write("scan"); Console.ResetColor(); Console.WriteLine("'."); } else //Inputs were found { Console.WriteLine("Known Inputs:"); foreach (var item in InputManager.Inputs) { Text.White("Command: "); Text.Green($@"{item.CommandText}"); Text.White(" From: "); Text.Cyan($"'{item.GetType().Name}'"); Text.WhiteLine($"\t\t{ item.Description} "); } } result.Success = true; result.Message = string.Empty; } else { var populator = InputManager.Inputs.Find(g => g.CommandText.Trim().ToLower() == args[1].Trim().ToLower()); if (populator != null) { await genesis.ConfigurePopulator(populator); Text.White($@"The current Populator is now: "); Text.CyanLine($"'{populator.GetType().Name}'"); result.Success = true; result.Message = string.Empty; } else { Console.Write("'"); Console.ForegroundColor = ConsoleColor.Yellow; Console.Write(args[1]); Console.ResetColor(); Console.Write("'"); Console.WriteLine(" is not a known Populator name."); result.Message = "Invalid Populator.Name"; } } return(await Task.FromResult(result)); }
public override async Task <ITaskResult> Execute(GenesisContext genesis, string[] args) { //NOTE: This apparently can't affect anything on the Program class itself. (without some voodoo) //So, just dump some text and check for this command in Program. Text.DarkYellowLine("Breaking..."); return(await Task.FromResult(new BlankTaskResult())); }
public override async Task <ITaskResult> Execute(GenesisContext genesis, string[] args) { var net = new HttpClient(); var yamlString = await net.GetStringAsync(Config.Address); Text.DarkYellowLine(yamlString); return(await base.Execute(genesis, args)); }
public override async Task <ITaskResult> Execute(GenesisContext genesis, string[] args) { Debug.WriteLine($@"{GetType().Name}.{nameof(Execute)}"); Console.WriteLine("Exiting"); Environment.Exit(0); //untz return(await Task.FromResult(new BlankTaskResult())); }
public CompanyRepositoryTests() { var options = new DbContextOptionsBuilder <GenesisContext>() .UseInMemoryDatabase("TestInMemoryDb") .Options; _context = new GenesisContext(options); BuildContext(); _repository = new CompanyRepository(_context); }
public override async Task <IGenesisExecutionResult> Execute(GenesisContext genesis, string[] args) { genesis.Objects.Clear(); Text.GrayLine("Objects have been reset"); Text.WhiteLine("Clearing the Chain"); genesis.Chain.Clear(); return(await Task.FromResult(new BlankGenesisExecutionResult())); //because nothing broke and we have nothing to report. :| (uh) }
public override async Task <IGenesisExecutionResult> Execute(GenesisContext genesis, string[] args) { var result = new OutputGenesisExecutionResult(); foreach (var obj in genesis.Objects) { await ExecuteGraph(obj); } return(result); }
public override async Task <IGenesisExecutionResult> Execute(GenesisContext genesis, string[] args) { Text.DarkGrayLine($@"Generating MVC Controllers in: {Config.OutputPath}"); foreach (var obj in genesis.Objects) { await ExecuteGraph(obj); } return(new OutputGenesisExecutionResult()); }
public ImportSectionViewModel(IExcelService excelService) { DisplayName = "Import"; Order = 50; context = new GenesisContext(); this.excelService = excelService; Sheets = new ObservableCollection<string>(); Columns = new ObservableCollection<ColumnViewModel>(); }
public override async Task <ITaskResult> Execute(GenesisContext genesis, string[] args) { var result = new OutputTaskResult(); //overridden just to loop over all the graphs foreach (var obj in genesis.Objects) { await ExecuteGraph(obj); } return(result); }
public override async Task <IGenesisExecutionResult> Execute(GenesisContext genesis, string[] args) { //NOTE: This apparently can't affect anything on the Program class itself. (without some voodoo) //So, just dump some text and check for this command in Program. Text.DarkYellowLine("Breaking..."); Text.Yellow($"Dumping to a prompt, ["); Text.CliCommand(GetType().Name.Replace("Command", "")); Text.YellowLine($"] was called."); Text.Line(); return(await Task.FromResult(new BlankGenesisExecutionResult())); }
public override async Task <IGenesisExecutionResult> Execute(GenesisContext genesis, string[] args) { Text.DarkGrayLine($@"Generating MVC Controllers in: {Config.OutputPath}"); var result = new OutputGenesisExecutionResult(); //overridden just to loop over all the graphs foreach (var obj in genesis.Objects) { await ExecuteGraph(obj); } return(result); }
protected override void OnActivate() { base.OnActivate(); if (context != null) context.Dispose(); context = new GenesisContext(); Localities.Clear(); Localities.AddRange(context.Localities); }
public override async Task <ITaskResult> Execute(GenesisContext genesis, string[] args) { var result = new OutputTaskResult(); if (args.Length == 1) //config { await OnHelpRequested(args); } else if (args.Length == 2) //config executorname { WriteExecutorDetails(args[1]); } else { var generator = OutputManager.Outputs.Find(g => g.CommandText.Trim().ToLower().Equals(args[1].Trim().ToLower(), StringComparison.Ordinal)); var populator = InputManager.Inputs.Find(p => p.CommandText.Trim().ToLower() == args[1].Trim().ToLower()); var chunks = args[2].Split('='); var propertyName = chunks[0]; if (generator != null) { if (!await generator.EditConfig(chunks[0], chunks[1])) { Text.RedLine("Couldn't update value"); } else { result.Success = true; } } else if (populator != null) { if (!await populator.EditConfig(chunks[0], chunks[1])) { Text.RedLine("Couldn't update value"); } else { result.Success = true; } } else { Text.Command(args[1]); Text.RedLine(" is not a known Executor. ("); Text.FriendlyText("Input", false); Text.Red(" or "); Text.FriendlyText("Output"); Text.RedLine("."); result.Message = "Invalid Executor"; } } return(await Task.FromResult(result)); }
static void Main(string[] args) { // var optionsBuilder = new DbContextOptionsBuilder<GenesisContext>(); //optionsBuilder.UseSqlServer("Data Source =.\\sqlexpress; Initial Catalog = Genesis; Integrated Security = True; MultipleActiveResultSets = True"); var optionsBuilder = new DbContextOptionsBuilder <GenesisContext>(); optionsBuilder.UseSqlServer("Server=tcp:genesissqlserver.database.windows.net,1433;Initial Catalog=genesis;Persist Security Info=False;User ID={genesisadmin};Password={Shafiro1};MultipleActiveResultSets=False;Encrypt=True;TrustServerCertificate=False;Connection Timeout=30;"); var dbc = new GenesisContext(optionsBuilder.Options); //AppData.InitCompanyData(dbc); HallsInfo.Init(dbc); Console.WriteLine("Hello World!"); }
public override async Task <IGenesisExecutionResult> Execute(GenesisContext genesis, string[] args) { var btr = new BlankGenesisExecutionResult(); var exeName = args[1]; //NOTE: Added that default help stuff for commands. Copy / Pasted 'gen' command here ;) var exe = GetExecutor(exeName); await exe.DisplayConfiguration(); Text.Line(); return(await Task.FromResult(btr)); }
public override async Task <IGenesisExecutionResult> Execute(GenesisContext genesis, string[] args) { if (args.Length == 2) { WriteUsage(); return(await Task.FromResult(new BlankGenesisExecutionResult())); } _ = args[2].ToLower() switch { "--dump" => WriteObjectGraphToStorage(genesis), _ => WriteUsage() }; return(await Task.FromResult(new BlankGenesisExecutionResult())); }
public override async Task <ITaskResult> Execute(GenesisContext genesis, string[] args) { await CommandLoader.InitAsync(args); Text.Line(); Text.Cyan("Genesis"); Text.GrayLine($" {Program.GetVersionDisplayString()}"); Text.Line(); foreach (var cmd in CommandLoader.Commands) { Text.Green($"\t{cmd.Name}"); Text.WhiteLine($"\t{cmd.Description}"); } return(await Task.FromResult(new BlankTaskResult() { Success = true, Message = "" })); }
public SettingsSectionViewModel() { DisplayName = "Settings"; Order = 100; var method = ActionMessage.GetTargetMethod; ActionMessage.GetTargetMethod = (message, o) => { return method(message, o); }; if (Execute.InDesignMode) { context = new GenesisContext(); context.Species.Load(); } }
public override async Task <IGenesisExecutionResult> Execute(GenesisContext genesis, string[] args) { Text.Line(); Text.DarkCyanLine("How this works:"); Text.White("*"); Text.YellowLine("\tDiscover Executor interfaces in the libraries that are right next to the cli. (for now)"); Text.CliCommand("\tscan", false); Text.Line(); Text.Yellow("\tAdd an Executor to the chain. "); Text.GrayLine("(probably an Input/Source/Origin)"); Text.CliCommand("\tadd ", false); Text.CliCommand("mssql", false); Text.GrayLine(); Text.Yellow("\tAdd another Executor. "); Text.GrayLine("(Output/Destination/Target)"); Text.CliCommand("\tadd ", false); Text.CliCommand("poco", false); Text.GrayLine(); Text.Yellow("\tExecute the chain sequentially. mssql populates ObjectGraphs, then poco reads them and writes out class files."); Text.GrayLine(); Text.CliCommand("\texec chain ", false); Text.DarkGrayLine("\t\t\t\t(double check config for mssql.ConnectionString"); Text.Line(); Text.Line(); Text.GrayLine("This effectively reads sql schema so that a poco generator can access that schema and do what it needs to. In this case, it's to write c# class files for each of the Sql Table objects."); return(await Task.FromResult(new BlankGenesisExecutionResult { Success = true, Message = "" }));; }
public override async Task <IGenesisExecutionResult> Execute(GenesisContext genesis, string[] args) { var result = new BlankGenesisExecutionResult() { Success = true, Message = "" }; Text.Line(); Text.YellowLine("Scanning for Inputs:"); await InputManager.InitializeInputsAsync(true); Text.Line(); Text.YellowLine("Scanning for Outputs:"); await OutputManager.InitializeGeneratorsAsync(true); Text.Line(); Text.YellowLine("Scanning for General Executors: "); await GeneralManager.InitializeGeneratorsAsync(true); Text.Line(); Console.ForegroundColor = (InputManager.Inputs.Count > 0) ? ConsoleColor.Green : ConsoleColor.Yellow; Text.White($@"{InputManager.Inputs.Count}"); Text.WhiteLine($" Potential Input(s)"); Console.ForegroundColor = (OutputManager.Outputs.Count > 0) ? ConsoleColor.Green : ConsoleColor.Yellow; Text.White($"{OutputManager.Outputs.Count}"); Text.WhiteLine(" Possible Output(s)"); Console.ForegroundColor = (GeneralManager.Current.Count > 0) ? ConsoleColor.Green : ConsoleColor.Yellow; Text.White($"{GeneralManager.Current.Count}"); Text.WhiteLine(" General Executor(s)"); Text.Line(); Text.White("The "); Text.Green("green"); Text.WhiteLine(" text is how you reference an Executor. "); Text.Line(); genesis.ScanCount++; return(await Task.FromResult(result)); }
public override async Task <IGenesisExecutionResult> Execute(GenesisContext genesis, string[] args) { if (!Directory.Exists(Config.OutputPath)) { Directory.CreateDirectory(Config.OutputPath); } var path = !string.IsNullOrEmpty(Config.DepsPath) && Directory.Exists(Config.DepsPath) ? Config.DepsPath : Config.OutputPath; await DepositDependencies(path); foreach (var obj in genesis.Objects) { await ExecuteGraph(obj); } return(new OutputGenesisExecutionResult()); }
public override async Task <IGenesisExecutionResult> Execute(GenesisContext genesis, string[] args) { var result = new OutputGenesisExecutionResult(); if (!Directory.Exists(Config.OutputPath)) //TODO: Worry about the output path in the OutputGenerator base { Directory.CreateDirectory(Config.OutputPath); } await DepositDependencies(); foreach (var obj in genesis.Objects) { await ExecuteGraph(obj); } result.Success = true; return(result); }
public override async Task <IGenesisExecutionResult> Execute(GenesisContext genesis, string[] args) { var result = new OutputGenesisExecutionResult(); try { foreach (var obj in genesis.Objects) { await ExecuteGraph(obj); } result.Success = true; } catch (Exception e) { Debug.WriteLine(e.Message); result.Message = e.Message; } return(result); }
public override async Task <ITaskResult> Execute(GenesisContext genesis, string[] args) { var tmp = GetSchema(); Text.BlueLine($"{GetType().Name} created {tmp.Count} ObjectGraph(s)"); foreach (var i in tmp) { Text.DarkYellowLine($"{i.Name}:{i.SourceType}"); if (genesis.Objects.SingleOrDefault(x => x.KeyId == i.KeyId) == null) { await genesis.AddObject(i); //yeah, this can blow up - leaving it for errors } } Text.CyanLine("Populated " + genesis.Objects.Count().ToString() + " object(s)."); return(await Task.FromResult(new InputTaskResult { Success = true, })); }
private static PropertyChangedBase WrapTraitIntoModel(Trait trait, GenesisContext context) { var ordinal = trait as OrdinalTrait; if (ordinal != null) return new OrdinalTraitViewModel(ordinal); var nominal = trait as NominalTrait; if (nominal != null) { return new NominalTraitViewModel(nominal, context); } throw new NotSupportedException("Unknown trait type."); }
public GeneViewModel(Gene gene, GenesisContext context) : base(gene, context) { this.gene = gene; }
public MiceSheetColumnViewModel(int columnIndex, string name, GenesisContext context) : base(columnIndex, name) { this.context = context; ApplyConvention(name); }
public ChromosomeViewModel(Chromosome chromosome, GenesisContext context) { this.chromosome = chromosome; this.context = context; Genes = new ObservableCollection<GeneViewModel>(chromosome.Genes.Select(g => new GeneViewModel(g, context))); }
public async void Analyze() { currentAnalysis = new FstAnalyzer(AnalysisName, new FstAnalyzer.Settings() { Genes = Genes.Where(g => g.Selected).Select(g => g.Gene).ToList(), Species = SelectedSpecies }); var context = new GenesisContext(); var result = await Task.Run(() => currentAnalysis.Analyse(context)); context.FstAnalysis.Add(result); context.SaveChanges(); }
public TraitCellEditorViewModel(Trait preselctedValue, GenesisContext context) { this.context = context; Trait = preselctedValue; }
protected override void OnActivate() { base.OnActivate(); context?.Dispose(); context = new GenesisContext(); context.Species.Load(); traits = null; NotifyOfPropertyChange(() => Traits); NotifyOfPropertyChange(() => Species); }
public new void Refresh() { if (context != null) context.Dispose(); context = new GenesisContext(); Genes.Clear(); foreach (var gene in context.Genes) { Genes.Add(new GeneViewModel(gene)); } NotifyOfPropertyChange(() => FstAnalysis); NotifyOfPropertyChange(() => Species); SelectedSpecies = Species.FirstOrDefault(); }
protected override void OnActivate() { base.OnActivate(); if (context != null) context.Dispose(); context = new GenesisContext(); NotifyOfPropertyChange(() => FrequencyAnalysis); NotifyOfPropertyChange(() => Localities); UpdateData(); }
private void ReloadData() { if (context != null) context.Dispose(); context = new GenesisContext(); Traits.Clear(); foreach (var gene in context.Genes.OrderBy(g => g.StartBasePair)) { Traits.Add(new NominalTraitViewModel(gene)); } NotifyOfPropertyChange(() => FrequencyAnalysis); }
protected override void OnActivate() { base.OnActivate(); if (context != null) context.Dispose(); context = new GenesisContext(); NotifyOfPropertyChange(() => Mice); NotifyOfPropertyChange(() => Genes); }
public async void Analyze() { currentAnalysis = new FrequencyAnalyzer(AnalysisName, new FrequencyAnalyzer.Settings() { Traits = Traits.Where(g => g.Selected).Select(g => g.Trait).ToList() }); var context = new GenesisContext(); var result = await Task.Run(() => currentAnalysis.Analyse(context)); context.FrequencyAnalysis.Add(result); context.SaveChanges(); ReloadData(); }
protected override void OnActivate() { if (context != null) { context.Dispose(); context = new GenesisContext(); context.Traits.Load(); } LoadColumns(); }