public override async Task <int> Handle(CArgument argument, IHost host, CancellationToken cancellationToken)
{
Workspace workspace = host.Services.GetRequiredService <Workspace>();
ILogger <CompleteCommand> logger = host.Services.GetRequiredService <ILogger <CompleteCommand> >();
await foreach (var id in workspace.Local.PostService.All(cancellationToken))
{
var post = await workspace.Local.PostService.Get(id, cancellationToken);
if (post is null)
{
continue;
}
if (argument.Force)
{
var meta = workspace.Local.InnerPostService.InnerRepository.GetDefaultMetadata(id);
meta.ApplyTo(post);
}
await workspace.Local.PostService.Update(post, cancellationToken);
logger.LogInformation($"Complete {post.Title}.");
}
return(0);
}
public override async Task <int> Handle(CArgument argument, IHost host, CancellationToken cancellationToken)
{
Workspace workspace = host.Services.GetRequiredService <Workspace>();
IBlogService service;
if (argument.Remote)
{
await workspace.Connect();
service = workspace.Remote;
}
else
{
service = workspace.Local;
}
await foreach (var id in service.PostService.All(cancellationToken))
{
var item = await service.PostService.Get(id, cancellationToken);
if (item is not null)
{
Console.WriteLine(item.Title);
}
}
return(0);
}
public override async Task <int> Handle(CArgument argument, ParserContext parser, PipelineContext pipeline, CancellationToken cancellationToken)
{
IWorkspace workspace = pipeline.Services.GetWorkspace();
ITerminal terminal = pipeline.Services.GetTerminal();
if (!argument.Clear)
{
IWorkItem?res = await workspace.Create("", null,
(vars, resolveContext) => Utils.ResolveCallback(vars, resolveContext, parser, pipeline));
if (res != null)
{
pipeline.Services.Replace <IWorkItem>(res);
}
else
{
terminal.Output.WriteErrorLine("Create work-item failed.");
return(-1);
}
}
else
{
pipeline.Services.Remove <IWorkItem>();
}
return(0);
}
public override async Task <int> Handle(CArgument argument, IHost host, CancellationToken cancellationToken)
{
Workspace workspace = host.Services.GetRequiredService <Workspace>();
if (workspace.Option.Remotes.TryGetValue(argument.Name, out var remote))
{
if (argument.Token != null)
{
remote.Token = argument.Token;
}
if (argument.Type != null)
{
remote.Type = argument.Type.Value;
}
if (argument.Uri != null)
{
if (remote.Type == RemoteType.LocalFS)
{
remote.Uri = new DirectoryInfo(argument.Uri).FullName;
}
else
{
remote.Uri = argument.Uri;
}
}
}
await workspace.Save();
return(0);
}
public override async Task <int> Handle(CArgument argument, IHost host, CancellationToken cancellationToken)
{
Workspace workspace = host.Services.GetRequiredService <Workspace>();
await workspace.Initialize();
return(0);
}
public override Task <int> Handle(CArgument argument, ParserContext parser, PipelineContext pipeline, CancellationToken cancellationToken)
{
ITerminal terminal = pipeline.Services.GetTerminal();
terminal.Clear();
return(Task.FromResult(0));
}
protected override Task <int> Handle(CArgument argument, IConsole console, InvocationContext context, PipelineContext pipeline, CancellationToken cancellationToken)
{
IHost host = pipeline.Services.Get <IHost>();
host.Shutdown();
return(Task.FromResult(0));
}
protected override async Task <int> Handle(CArgument argument, IConsole console, InvocationContext context, PipelineContext pipeline, CancellationToken cancellationToken)
{
IWorkspace workspace = pipeline.Services.GetWorkspace();
ITerminal terminal = console.GetTerminal();
string template = argument.Template;
Packagings.Package <BaseTemplate>?tplItem = await workspace.Templates.GetValue(template);
if (tplItem == null)
{
terminal.OutputErrorLine($"No this template: {template}.");
return(1);
}
BaseTemplate?tpl = tplItem.Data;
if (tpl == null)
{
terminal.OutputErrorLine($"Can not load this template: {template}.");
return(1);
}
IWorkItem?item = null;
try
{
item = await workspace.Create(argument.Name, tpl,
(vars, resolveContext) => Utils.ResolveCallback(vars, resolveContext, context, pipeline));
}
catch (ArgumentException)
{
return(-1);
}
return(0);
}
public override Task <int> Handle(CArgument argument, ParserContext parser, PipelineContext pipeline, CancellationToken cancellationToken)
{
IHost host = pipeline.Services.GetService <IHost>();
host.Shutdown();
return(Task.FromResult(0));
}
public override async Task <int> Handle(CArgument argument, IConsole console, InvocationContext context, CancellationToken cancellationToken)
{
Workspace workspace = Program.Workspace;
workspace.Configuration.Remote = null;
workspace.Configuration.Token = "";
await workspace.Save();
{
DirectoryInfo di = new DirectoryInfo(workspace.GetPostRoot());
if (!di.Exists)
{
di.Create();
}
}
{
DirectoryInfo di = new DirectoryInfo(workspace.GetCategoryRoot());
if (!di.Exists)
{
di.Create();
}
}
{
DirectoryInfo di = new DirectoryInfo(workspace.GetKeywordRoot());
if (!di.Exists)
{
di.Create();
}
}
return(0);
}
public override async Task <int> Handle(CArgument argument, IHost host, CancellationToken cancellationToken)
{
Workspace workspace = host.Services.GetRequiredService <Workspace>();
ILogger <PostCommand> logger = host.Services.GetRequiredService <ILogger <PostCommand> >();
Post post = new Post
{
Id = argument.Id,
Title = argument.Title,
CreationTime = DateTimeOffset.Now,
ModificationTime = DateTimeOffset.Now,
Type = argument.Type,
};
var id = await workspace.Local.PostService.Create(post, cancellationToken);
if (string.IsNullOrEmpty(id))
{
logger.LogError("Create failed.");
return(1);
}
else
{
logger.LogInformation($"Create post: {id}.");
return(0);
}
}
public object CreateParameters(CArgument arg, ParameterInfo info)
{
if (arg is CFunction)
{
CFunction f = arg as CFunction;
if (f.Name.Equals("null"))
{
return(null);
}
if (info.ParameterType.BaseType == typeof(ValueType) || info.ParameterType.BaseType == typeof(Enum))
{
return(CreateBase(f, info.ParameterType));
}
else if (info.ParameterType.BaseType == typeof(Array) && f.Name.Equals("a"))
{
Array array = info.ParameterType.GetConstructors()[0].Invoke(new object[] { f.Arguments.Count }) as Array;
for (int i = 0; i < array.Length; i++)
{
if (f.Arguments[i] is CFunction)
{
object param = CreateBase(f.Arguments[i] as CFunction, info.ParameterType);
array.SetValue(param, i);
}
}
return(array);
}
else
{
if (f.Name.Equals("ctor"))
{
CFunction target = f.Arguments[0] as CFunction;
int index = int.Parse(f.Arguments[1].Text);
if (!info.ParameterType.Name.Equals(f.Arguments[0]))
{
throw new EntryPointNotFoundException("Could not find Constructor for: " + info.ParameterType.Name);
}
ConstructorInfo constructor = info.ParameterType.GetConstructors()[index];
ParameterInfo[] infos = constructor.GetParameters();
object[] args = new object[infos.Length];
for (int i = 0; i < infos.Length; i++)
{
args[i] = CreateParameters(target.Arguments[i], infos[i]);
}
return(constructor.Invoke(args));
}
else
{
throw new Exception("Could not handle CFunction");
}
}
}
else
{
return((arg as CText)?.Text);
}
}
public override async Task <int> Handle(CArgument argument, IConsole console, InvocationContext context, CancellationToken cancellationToken)
{
Workspace workspace = Program.Workspace;
using var client = new HttpClient();
await workspace.Connect(client);
return(0);
}
public override async Task <int> Handle(CArgument argument, IConsole console, InvocationContext context, CancellationToken cancellationToken)
{
Workspace workspace = Program.Workspace;
workspace.Configuration.Token = "";
await workspace.Save();
return(0);
}
protected override Task <int> Handle(CArgument argument, IConsole console, InvocationContext context, PipelineContext pipeline, CancellationToken cancellationToken)
{
ITerminal terminal = console.GetTerminal();
CommandCollection manager = pipeline.Services.GetCommands();
terminal.OutputTable(manager,
new OutputTableColumnStringView <ICommandBuilder>(x => x.Name, nameof(ICommandBuilder.Name)),
new OutputTableColumnStringView <ICommandBuilder>(x => manager.GetExtension(x)?.Name ?? "N/A", "Extension")
);
return(Task.FromResult(0));
}
public override async Task <int> Handle(CArgument argument, IConsole console, InvocationContext context, CancellationToken cancellationToken)
{
Workspace workspace = Program.Workspace;
workspace.Configuration.Remote = new ServerConfiguration(argument.Uri !, argument.Static);
using var client = new HttpClient();
await workspace.Connect(client);
await workspace.Save();
return(0);
}
protected override Task <int> Handle(CArgument argument, IConsole console, InvocationContext context, PipelineContext pipeline, CancellationToken cancellationToken)
{
ITerminal terminal = console.GetTerminal();
terminal.Clear();
terminal.SetCursorPosition(0, 0);
if (console is SystemConsole)
{
System.Console.Clear();
System.Console.SetCursorPosition(0, 0);
}
return(Task.FromResult(0));
}
protected override Task <int> Handle(CArgument argument, IConsole console, InvocationContext context, PipelineContext pipeline, CancellationToken cancellationToken)
{
ITerminal terminal = console.GetTerminal();
ExtensionCollection manager = pipeline.Services.GetExtensions();
terminal.OutputTable(manager,
new OutputTableColumnStringView <ExtensionLoader>(x => x.Extension.Name, nameof(IExtension.Name)),
new OutputTableColumnStringView <ExtensionLoader>(x => x.Extension.Description ?? "N/A", nameof(IExtension.Description)),
new OutputTableColumnStringView <ExtensionLoader>(x => x.Extension.Publisher ?? "N/A", nameof(IExtension.Publisher)),
new OutputTableColumnStringView <ExtensionLoader>(x => x.Extension.Version.ToString() ?? "N/A", nameof(IExtension.Version))
);
return(Task.FromResult(0));
}
public override async Task <int> Handle(CArgument argument, IHost host, CancellationToken cancellationToken)
{
Workspace workspace = host.Services.GetRequiredService <Workspace>();
workspace.Option.Remotes.Remove(argument.Name);
if (workspace.Option.CurrentRemote == argument.Name)
{
workspace.Option.CurrentRemote = string.Empty;
}
await workspace.Save();
return(0);
}
public override async Task <int> Handle(CArgument argument, IHost host, CancellationToken cancellationToken)
{
Workspace workspace = host.Services.GetRequiredService <Workspace>();
var logger = host.Services.GetRequiredService <ILogger <LoginCommand> >();
if (string.IsNullOrWhiteSpace(argument.Name))
{
argument.Name = workspace.Option.CurrentRemote;
}
if (workspace.Option.Remotes.TryGetValue(argument.Name, out var remote))
{
await workspace.Connect(remote.Name);
string userName = string.Empty, password = string.Empty;
{
if (string.IsNullOrEmpty(userName))
{
userName = ConsoleExtensions.Input("Input username: "******"Input password: "******"Login failed.");
}
else
{
remote.Token = token;
await workspace.Save();
}
}
catch
{
logger.LogError("Login failed.");
}
}
return(0);
}
public void Loop(string cmd, LightingConsole console)
{
CArgument a = ParseString(cmd);
if (a is CText)
{
throw new Exception("No Function in Command");
}
else
{
CFunction func = a as CFunction;
HandleFunction(func, console);
}
}
protected override Task <int> Handle(CArgument argument, IConsole console, InvocationContext context, PipelineContext pipeline, CancellationToken cancellationToken)
{
ILogger logger = pipeline.Services.GetLogger();
ITerminal terminal = console.GetTerminal();
{
terminal.OutputTable(logger.View(),
new OutputTableColumnLogLevelView(nameof(LogItem.Level)),
new OutputTableColumnStringView <LogItem>(x => x.Scope, nameof(LogItem.Scope)),
new OutputTableColumnStringView <LogItem>(x => x.Time.ToString(CultureInfo.InvariantCulture.DateTimeFormat), nameof(LogItem.Time)),
new OutputTableColumnStringView <LogItem>(x => x.Content, nameof(LogItem.Content))
);
}
return(Task.FromResult(0));
}
public override async Task <int> Handle(CArgument argument, ParserContext parser, PipelineContext pipeline, CancellationToken cancellationToken)
{
IWorkspace workspace = pipeline.Services.GetWorkspace();
if (argument.Delete)
{
await workspace.Clear();
}
else
{
await workspace.Initialize();
await workspace.Templates.SetValue("c", Resources.Programming.FileTemplates.C);
await workspace.Templates.SetValue("python", Resources.Programming.FileTemplates.Python);
await workspace.Templates.SetValue("cpp", Resources.Programming.FileTemplates.Cpp);
await workspace.Templates.SetValue("csharp", Resources.Programming.FileTemplates.CSharp);
await workspace.Templates.SetValue("python", Resources.Programming.FileTemplates.Python);
await workspace.Templates.SetValue("fsharp", Resources.Programming.FileTemplates.FSharp);
await workspace.Templates.SetValue("go", Resources.Programming.FileTemplates.Go);
await workspace.Templates.SetValue("java", Resources.Programming.FileTemplates.Java);
await workspace.Templates.SetValue("dir", new Package <ITemplate>(FileBasedCommandLineOperation.GetDirectoryTemplate()));
await workspace.Operations.SetValue("c", Resources.Programming.FileOperations.C);
await workspace.Operations.SetValue("python", Resources.Programming.FileOperations.Python);
await workspace.Operations.SetValue("cpp", Resources.Programming.FileOperations.Cpp);
await workspace.Operations.SetValue("python", Resources.Programming.FileOperations.Python);
await workspace.Operations.SetValue("go", Resources.Programming.FileOperations.Go);
await workspace.Operations.SetValue("ruby", Resources.Programming.FileOperations.Ruby);
await workspace.Operations.SetValue("javascript", Resources.Programming.FileOperations.JavaScript);
await workspace.Operations.SetValue("dir", new Package <IOperation>(new FileBasedCommandLineOperation()));
}
return(0);
}
protected override async Task <int> Handle(CArgument argument, IConsole console, InvocationContext context, PipelineContext pipeline, CancellationToken cancellationToken)
{
Manager manager = pipeline.Services.GetManager();
if (argument.Delete)
{
await manager.Clear();
}
else
{
await manager.Initialize();
}
CodeRunner.Extensions.IHost host = pipeline.Services.GetHost();
((ExtensionHost)host).Restart();
return(0);
}
public override async Task <int> Handle(CArgument argument, IHost host, CancellationToken cancellationToken)
{
Workspace workspace = host.Services.GetRequiredService <Workspace>();
if (argument.Current is null)
{
Console.WriteLine($"Current: {workspace.Option.CurrentRemote}");
foreach (var item in workspace.Option.Remotes.Values)
{
Console.WriteLine($"{item.Name} ({Enum.GetName(typeof(RemoteType), item.Type)}): {item.Uri}");
}
}
else
{
workspace.Option.CurrentRemote = argument.Current;
await workspace.Save();
}
return(0);
}
public override async Task <int> Handle(CArgument argument, IConsole console, InvocationContext context, CancellationToken cancellationToken)
{
Workspace workspace = Program.Workspace;
using var client = new HttpClient();
await workspace.Connect(client);
var service = workspace.Remote !.PostService;
var list = (await service.All(cancellationToken)).ToList();
console.Out.WriteLine($"Founded {list.Count} posts.");
var items = await Task.WhenAll(list.Select(id => service.Get(id, cancellationToken)));
foreach (var item in items)
{
cancellationToken.ThrowIfCancellationRequested();
console.Out.WriteLine(item !.Title);
}
return(0);
}
public override async Task <int> Handle(CArgument argument, IHost host, CancellationToken cancellationToken)
{
Workspace workspace = host.Services.GetRequiredService <Workspace>();
if (argument.Type == RemoteType.LocalFS)
{
argument.Uri = new DirectoryInfo(argument.Uri).FullName;
}
workspace.Option.Remotes.Add(argument.Name, new RemoteOption
{
Name = argument.Name,
Uri = argument.Uri,
Type = argument.Type,
Token = argument.Token
});
if (string.IsNullOrEmpty(workspace.Option.CurrentRemote))
{
workspace.Option.CurrentRemote = argument.Name;
}
await workspace.Save();
return(0);
}
protected override async Task <int> Handle(CArgument argument, IConsole console, InvocationContext context, PipelineContext pipeline, CancellationToken cancellationToken)
{
Environment.CurrentDirectory = argument.Directory !.FullName;
pipeline.Services.Add <IWorkspace>(new Managements.FSBased.Workspace(argument.Directory));
ILogger logger = pipeline.Services.GetLogger();
if (argument.Command != "")
{
Parser repl = CommandLines.CreateDefaultParser(pipeline.Services.GetReplCommand(), pipeline);
pipeline.IsStopped = true;
return(await repl.InvokeAsync(argument.Command, console));
}
if (argument.Verbose)
{
}
else
{
_ = logger.UseLevelFilter(LogLevel.Information);
}
return(0);
}
protected override Task <int> Handle(CArgument argument, IConsole console, InvocationContext context, PipelineContext pipeline, CancellationToken cancellationToken)
{
Environment.CurrentDirectory = argument.Directory !.FullName;
{
Manager manager = new Manager(new DirectoryInfo(Environment.CurrentDirectory));
pipeline.Services.Add <Manager>(manager);
}
pipeline.Services.Add <string>("fs", ServicesExtensions.ArgWorkspaceNameId);
pipeline.Services.Add <string>(argument.Command, ServicesExtensions.ArgCommandId);
ILogger logger = pipeline.Services.GetLogger();
if (argument.Verbose)
{
}
else
{
_ = logger.UseLevelFilter(LogLevel.Information);
}
return(Task.FromResult(0));
}
public void VisitFile(CFile file)
{
if (!canGenerate(file))
{
return;
}
visitor.PreVisitFile(file);
filenamesrc = file.Token;
new CNewline(null).Accept(visitor);
if (instrument)
{
COption cCodeCoverage =
new COption(new CToken(file.Filename, TokenTypes.keyword, "option"),
new CToken(file.Filename, TokenTypes.keyword, "include"),
new CToken(file.Filename, TokenTypes.str, "cCodeCoverage.asp"));
cCodeCoverage.Accept(this);
}
visitor.VisitFile(file);
if (file.Attributes.contains("GenerateProcessAjaxFunction"))
{
CFunction unicoderequest = CProgram.Global.FindFunction("unicoderequest");
CFunction intrequest = CProgram.Global.FindFunction("intrequest");
CFunction boolrequest = CProgram.Global.FindFunction("boolrequest");
CToken tok = CreateTokenWithAdditionalInfo("ProcessAjax", "processajax", TokenTypes.identifier);
CFunction processAjax =
new CFunction(tok, tok.RawValue, tok.Value, TokenTypes.visPublic, CFunction.vbSub, null,
new CTypeRef(null, BuiltIns.Void));
CAccess pivotitem = new CAccess(unicoderequest.Token, unicoderequest.Token);
pivotitem.ReferenceTarget = unicoderequest;
CParameters pivotparams = new CParameters();
pivotparams.Unnamed.Add(
new CConstantExpression(CreateTokenWithAdditionalInfo("sFunction", TokenTypes.str)));
CSelect select =
new CSelect(CreateTokenWithAdditionalInfo("select", TokenTypes.controlFlow),
new CDefaultAccess(pivotitem.Token, pivotitem, pivotparams));
IEnumerator it = CProgram.Global.Functions.GetEnumerator();
List <CVariable> vars = new List <CVariable>();
while (it.MoveNext())
{
CFunction func = (CFunction)it.Current;
if (!func.Attributes.contains("ExecuteOnServer"))
{
continue;
}
CStatementBlock block = new CStatementBlock();
CParameters funcParams = new CParameters();
for (int ixArg = 0; ixArg < func.Arguments.Count - 3; ixArg++)
{
CArgument arg = func.Arguments[ixArg];
tok =
CreateTokenWithAdditionalInfo("vParam" + (ixArg + 1), "vparam" + (ixArg + 1),
TokenTypes.identifier);
if (ixArg >= vars.Count)
{
vars.Add(new CVariable(tok, false, new CTypeRef(null, BuiltIns.Variant), null, null, null));
}
CAssignment assign = new CAssignment(tok);
CAccess left = new CAccess(tok, tok);
left.ReferenceTarget = vars[ixArg];
assign.Target = left;
funcParams.Unnamed.Add(left);
CFunction rightfunc = intrequest;
if (arg.Type.RawName == "Boolean")
{
rightfunc = boolrequest;
}
else if (arg.Type.RawName == "String")
{
rightfunc = unicoderequest;
}
CParameters parameters = new CParameters();
parameters.Unnamed.Add(
new CConstantExpression(CreateTokenWithAdditionalInfo(tok.RawValue, TokenTypes.str)));
CAccess rightitem = new CAccess(rightfunc.Token, rightfunc.Token);
rightitem.ReferenceTarget = rightfunc;
assign.Source = new CDefaultAccess(rightfunc.Token, rightitem, parameters);
assign.Source.RhsAssignmentSource = true;
block.Add(assign);
}
CAccess calledItem = new CAccess(func.Token, func.Token);
CDefaultAccess called = new CDefaultAccess(func.Token, calledItem, funcParams);
calledItem.ReferenceTarget = calledItem.ReferenceTarget = func;
if (func.Attributes.contains("picture") || func.FunctionType == CFunction.vbFunction)
{
CAccess returnItem = new CAccess(processAjax.Token, processAjax.Token);
returnItem.ReferenceTarget = processAjax;
CAssignment assign = new CAssignment(processAjax.Token);
assign.Target = returnItem;
if (func.FunctionType == CFunction.vbFunction)
{
assign.Source = called;
}
else
{
assign.Source = new CPictureOfExpression(tok, called);
}
block.Add(assign);
}
else
{
block.Add(new CExpressionStatement(called));
}
tok = CreateTokenWithAdditionalInfo("case", TokenTypes.controlFlow);
CExpression exp =
new CConstantExpression(CreateTokenWithAdditionalInfo(func.RawName, TokenTypes.str));
select.Cases.Add(new CCase(tok, exp, block));
}
CDim dim = new CDim(CreateTokenWithAdditionalInfo("Dim", TokenTypes.declaration));
dim.Variables.AddRange(vars);
processAjax.Statements.Add(dim);
processAjax.Statements.Add(select);
CNewline nl = new CNewline(CreateTokenWithAdditionalInfo("\n", TokenTypes.newline));
nl.Accept(this);
processAjax.Accept(this);
nl.Accept(this);
}
}
