Ejemplo n.º 1
0
        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));
        }
Ejemplo n.º 2
0
        public override async Task <ITaskResult> Execute(GenesisContext genesis, string[] args)
        {
            var btr = new BlankTaskResult();

            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));
        }
Ejemplo n.º 3
0
        public override async Task <ITaskResult> Execute(GenesisContext genesis, string[] args)
        {
            var r = new BlankTaskResult();

            if (args.Length == 1)
            {
                Text.White("Specify something to execute. A ");
                Text.Command("command");
                Text.White(" or ");
                Text.Yellow("chain");
                Text.WhiteLine(" to execute the chain");

                return(r);
            }

            if (args[1] == "pop") //cheesy
            {
                return((InputTaskResult)await genesis.Populator.Execute(genesis, args));
            }
            else if (args[1] == "gen")
            {
                return((OutputTaskResult)await genesis.Generator.Execute(genesis, args));
            }
            else if (args[1] == "chain")
            {
                _ = genesis.Chain.Execute(args);
                return(new BlankTaskResult()); //whatever for now
            }
            else
            {
                var tmp = GetExecutor(args[1]);

                if (tmp == null)
                {
                    throw new InvalidOperationException("Invalid execution: " + args[0] + " " + args[1]);
                }

                return(await tmp.Execute(genesis, args));
            }
        }
Ejemplo n.º 4
0
        public override async Task <ITaskResult> Execute(GenesisContext genesis, string[] args)
        {
            var result = new BlankTaskResult();

            //TODO: Move help text to override in AddCommand
            if (args.Length == 1 || HelpWasRequested(args)) //just 'add' or 'add --help,-?'
            {
                Console.WriteLine("Usage:");
                Console.WriteLine($"\t{Name} <command>\t\tAdds an executor to the end of the Chain.");
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.WriteLine($"\t'{Name} ExecutorName'");
                Console.ResetColor();
                Console.WriteLine();

                if (OutputManager.Outputs.Count == 0 || InputManager.Inputs.Count == 0) //NO Executors found, this still needs combined
                {
                    Console.ForegroundColor = ConsoleColor.Yellow;
                    Console.Write("There are no inputs discovered yet. Run a ");
                    Text.Command("scan");
                    Console.WriteLine(".");
                }
                else
                {
                    Console.WriteLine("Known Inputs:"); //TODO: Get rid of Generator / Populator concept
                    foreach (var item in InputManager.Inputs)
                    {
                        Text.White("Input: "); Text.Green($@"{item.CommandText}"); Text.White(" From: "); Text.DarkCyanLine($"{item.GetType().Assembly.GetName().Name}");
                    }
                    Console.WriteLine();
                    Console.WriteLine("Known Outputs:"); //TODO: Get rid of Generator / Populator concept
                    foreach (var item in OutputManager.Outputs)
                    {
                        Text.White("Output: "); Text.Green($@"{item.CommandText}"); Text.White(" From: "); Text.DarkCyanLine($"{item.GetType().Assembly.GetName().Name}");
                    }
                }
                result.Success = true;
            }
            else
            {
                var generator = OutputManager.Outputs.Find(g => g.CommandText.Trim().ToLower() == args[1].Trim().ToLower());
                if (generator != null)
                {
                    await genesis.Chain.Append(generator);

                    Text.Command(generator.CommandText); Text.WhiteLine($@" was added to the Chain. There are {genesis.Chain.Count} now.");
                    result.Success = true;
                    return(result);
                }

                var populator = InputManager.Inputs.Find(p => p.CommandText.Trim().ToLower() == args[1].Trim().ToLower()); //this is silly
                if (populator != null)
                {
                    await genesis.Chain.Append(populator);

                    Text.Command(populator.CommandText); Text.WhiteLine($@" was added to the Chain. There are {genesis.Chain.Count} now.");
                    result.Success = true;
                    return(result);
                }

                Text.White("'");
                Text.Red(args[1]);
                Text.WhiteLine("' is not a known input or output.");
            }

            return(await Task.FromResult(result));
        }