public void ServiceAPI_IntegrationTests_1()
{
var engine = new ServiceEngine();
var session = engine.CreateSession("-f /dev/stdin", InputText);
Assert.True(session.IsActive);
var response = session.ExecuteCommand("bal checking --account=code");
Assert.False(response.HasErrors);
Assert.Equal(BalCheckingOutputText.Replace("\r", "").Trim(), response.OutputText.Trim());
response = session.ExecuteCommand("bal checking --account=code");
Assert.False(response.HasErrors);
Assert.Equal(BalCheckingOutputText.Replace("\r", "").Trim(), response.OutputText.Trim());
response = session.ExecuteCommand("bal");
Assert.False(response.HasErrors);
Assert.Equal(BalOutputText.Replace("\r", "").Trim(), response.OutputText.Trim());
response = session.ExecuteCommand("reg");
Assert.False(response.HasErrors);
Assert.Equal(RegOutputText.Replace("\r", "").Trim(), response.OutputText.Trim());
}
public MethodResponse <PlaceHolder> GetJsonPlaceHolder(string id)
{
var response = new MethodResponse <PlaceHolder>();
try
{
var serviceEngine = new ServiceEngine();
var data = serviceEngine.GetJsonPlaceHolder(id);
if (int.Parse(data.Code.ToString()) != 0)
{
return(new MethodResponse <PlaceHolder>()
{
Code = data.Code, Message = data.Message
});
}
response = data;
return(response);
}
catch (Exception ex)
{
return(new MethodResponse <PlaceHolder>()
{
Code = -1, Message = "Ocurrio un error en api JsonPlaceHolder: " + ex.Message
});
}
}
private async Task ServiceAPI_ServiceSession_Dispose_Verification_Action()
{
var DailyLedger = @"
; Income
2011/11/21 Payment for hard work completed
Bank:Paypal $350.00
Income:Hard Work
2012/7/1 Partial payment from Client X
Bank:Paypal $100
Receivable:ClientX";
var engine = new ServiceEngine();
for (int i = 0; i < 2; i++)
{
var inputText = string.Join(Environment.NewLine, "", "", DailyLedger).Trim();
using (var session = await engine.CreateSessionAsync("-f /dev/stdin", inputText).ConfigureAwait(false))
{
var result = await session.ExecuteCommandAsync("bal").ConfigureAwait(false);
if (result.HasErrors)
{
throw new Exception(result.ErrorText);
}
Assert.True(result.OutputText.Any());
}
}
}
internal void RaiseWorkStarted(ServiceEngine engine)
{
if (this.WorkStarted != null)
{
this.WorkStarted(engine, EventArgs.Empty);
}
}
internal void RaiseDisposed(ServiceEngine engine)
{
if (this.Disposed != null)
{
this.Disposed(engine, EventArgs.Empty);
}
}
private async Task <ServiceResponse> ServiceAPI_IntegrationTests_2_Exec(ServiceEngine serviceEngine)
{
var session = await serviceEngine.CreateSessionAsync("-f /dev/stdin", InputText);
var response = await session.ExecuteCommandAsync("bal checking --account=code");
return(response);
}
public void ServiceAPI_IntegrationTests_2()
{
var engine = new ServiceEngine();
var response = ServiceAPI_IntegrationTests_2_Exec(engine).Result;
Assert.False(response.HasErrors);
Assert.Equal(BalCheckingOutputText.Replace("\r", "").Trim(), response.OutputText.Trim());
}
public override void Log(string message, Level level)
{
if (!IsLogged(Level.Info))
{
return;
}
ServiceEngine.WriteToLog(message, LevelToEventLogEntryType(level));
}
protected void OnStart(string[] args)
{
assemblyPath = Settings.Default.AssemblyPath;
catalog = new DirectoryCatalog(AppDomain.CurrentDomain.BaseDirectory + assemblyPath);
container = new CompositionContainer(catalog);
engine = container.GetExportedValue <ServiceEngine>();
engine.OnStart(args);
}
public ServiceSelectForm(PatientViewForm patientViewForm, DbEngine dbEngine, ServiceEngine serviceEngine)
{
_stopSaveParameters = true;
InitializeComponent();
_dbEngine = dbEngine;
_patientViewForm = patientViewForm;
_serviceEngine = serviceEngine;
}
private async Task ExecuteCommand(string command)
{
if (command == "#test-color")
{
OutputText = GetTestColor();
return;
}
await SaveTextEditorContent();
await AddCommandToHistory(command);
var sourceKey = GetSourceKey();
var config = await GetEnvironmentalConfig();
var fileSystem = await FileSystemProviderConnector.GetProvider(); // TODO set current folder, set encoding
var engine = new ServiceEngine(
configureContext: context =>
{
context.IsAtty = config.IsAtty;
context.TimeZone = config.TimeZone;
context.SetEnvironmentVariables(config.EnvironmentVariables);
},
createCustomProvider: mem =>
{
mem.Attach(w => new MemoryAnsiTextWriter(w));
return(new ApplicationServiceProvider(
fileSystemProviderFactory: () => fileSystem,
virtualConsoleProviderFactory: () => new VirtualConsoleProvider(mem.ConsoleInput, mem.ConsoleOutput, mem.ConsoleError)));
});
ServiceSession session;
if (sourceKey == FileSystemRepository.InputStream.Key)
{
session = engine.CreateSession("-f /dev/stdin", await FileSystemRepository.GetFileContent(sourceKey));
}
else
{
session = engine.CreateSession($"-f {(await FileSystemRepository.GetItem(sourceKey)).Path}");
}
var response = session.ExecuteCommand(command);
OutputText = response.OutputText;
ErrorText = response.ErrorText;
ResultCode = response.Status;
// TODO - save possible changes in FS
//if (fileSystem.HasChanges())
// await FileSystemProviderConnector.ApplyChanges();
}
public void ServiceAPI_IntegrationTests_3()
{
var engine = new ServiceEngine();
var session = engine.CreateSessionAsync("-f /dev/stdin", InputText).Result;
var ex1 = CheckSessionResponseOutput(session.ExecuteCommandAsync("bal checking --account=code").Result, BalCheckingOutputText);
var ex2 = CheckSessionResponseOutput(session.ExecuteCommandAsync("bal").Result, BalOutputText);
var ex3 = CheckSessionResponseOutput(session.ExecuteCommandAsync("reg").Result, RegOutputText);
Assert.Null(CheckSessionResponseOutput(session.ExecuteCommandAsync("bal checking --account=code").Result, BalCheckingOutputText));
Assert.Null(CheckSessionResponseOutput(session.ExecuteCommandAsync("bal").Result, BalOutputText));
Assert.Null(CheckSessionResponseOutput(session.ExecuteCommandAsync("reg").Result, RegOutputText));
}
public static void LoadServices()
{
var serviceEngine = new ServiceEngine();
CompositionContainer.ComposeParts(serviceEngine);
foreach (var service in serviceEngine.Services)
{
if (service.IsInstaled)
service.OnServiceCreating(Builder);
Services.Add(service.Name, service);
}
}
public void ServiceAPI_IntegrationTests_5()
{
var engine = new ServiceEngine(
configureContext: context => { context.IsAtty = true; },
createCustomProvider: mem =>
{
mem.Attach(w => new MemoryAnsiTextWriter(w));
return(null);
});
var session = engine.CreateSession("-f /dev/stdin", InputText);
var response = session.ExecuteCommand("bal checking --account=code");
Assert.False(response.HasErrors);
Assert.Equal(BalCheckingOutputTextWithSpans.Replace("\r", "").Trim(), response.OutputText.Trim());
}
public NLedgerSession(string file)
{
if (!File.Exists(file))
{
throw new ArgumentException($"The file {file} does not exist.");
}
Engine = new ServiceEngine(
configureContext: context => { context.IsAtty = true; },
createCustomProvider: mem =>
{
mem.Attach(w => new MemoryAnsiTextWriter(w));
return(null);
});
Session = Engine.CreateSession(file);
Initialized = true;
}
public void ServiceAPI_IntegrationTests_7()
{
var engine = new ServiceEngine(
configureContext: context =>
{
context.SetEnvironmentVariables(new Dictionary <string, string>()
{
{ "COLUMNS", "120" }
});
});
var session = engine.CreateSession("-f /dev/stdin", InputText);
var response = session.ExecuteCommand("bal checking --account=code");
Assert.False(response.HasErrors);
Assert.Equal(BalCheckingOutputText.Replace("\r", "").Trim(), response.OutputText.Trim());
}
public void ServiceAPI_IntegrationTests_4()
{
var engine = new ServiceEngine();
var session = engine.CreateSession("-f /dev/stdin", InputText);
var tasks = new List <Task <Exception> >();
for (int i = 0; i < 10; i++)
{
tasks.Add(Task.Run(() => CheckSessionResponseOutput(session.ExecuteCommandAsync("bal checking --account=code").Result, BalCheckingOutputText)));
tasks.Add(Task.Run(() => CheckSessionResponseOutput(session.ExecuteCommandAsync("bal").Result, BalOutputText)));
tasks.Add(Task.Run(() => CheckSessionResponseOutput(session.ExecuteCommandAsync("reg").Result, RegOutputText)));
}
Task.WhenAll(tasks).Wait();
Assert.DoesNotContain(tasks, t => t.IsFaulted);
Assert.True(tasks.All(t => t.Result == null));
}
public void ServiceAPI_IntegrationTests_6()
{
var fs = new MemoryFileSystemProvider();
fs.CreateFile("input.dat", InputText);
var engine = new ServiceEngine(
createCustomProvider: mem =>
{
return(new ApplicationServiceProvider(
fileSystemProviderFactory: () => fs,
virtualConsoleProviderFactory: () => new VirtualConsoleProvider(mem.ConsoleInput, mem.ConsoleOutput, mem.ConsoleError)));
});
var session = engine.CreateSession("-f input.dat");
var response = session.ExecuteCommand("bal checking --account=code");
Assert.False(response.HasErrors);
Assert.Equal(BalCheckingOutputText.Replace("\r", "").Trim(), response.OutputText.Trim());
}
public void CanStartNLedger()
{
var engine = new ServiceEngine(
configureContext: context => { context.IsAtty = true; },
createCustomProvider: mem =>
{
mem.Attach(w => new MemoryAnsiTextWriter(w));
return null;
});
var session = engine.CreateSession("-f ledger.dat");
var journal = session.GlobalScope.Session.Journal;
Assert.True(session.IsActive);
var response = session.ExecuteCommand("bal checking --account=code");
session.ExecuteJournalAction((j) =>
{
Xact xact = new Xact();
xact.AddPost(new Post(journal.Master, new Amount(10, new NLedger.Commodities.Commodity(session.MainApplicationContext.CommodityPool, new NLedger.Commodities.CommodityBase("$")))));
xact.AddPost(new Post(journal.Master, new Amount(-10, new NLedger.Commodities.Commodity(session.MainApplicationContext.CommodityPool, new NLedger.Commodities.CommodityBase("$")))));
j.AddXact(xact);
//j.Master.AddAccount(new Account() { f})
});
// response = session.ExecuteCommand("bal checking --account=code");
//session.ExecuteCommand
//j
response = session.ExecuteCommand("bal");
//session.Dispose();
Assert.False(response.HasErrors);
Assert.Equal(2, session.GlobalScope.Session.Journal.Xacts.Count);
//session.ServiceEngine.
//Assert.Equal(BalCheckingOutputText.Replace("\r", "").Trim(), response.OutputText.Trim());
}
public LoginService(
ServiceEngine serviceEngine) : base(serviceEngine)
{
}
public LoginController(ServiceEngine serviceEngine, IMapper mapper) : base(mapper)
{
this._serviceEngine = serviceEngine;
}
public void ProcessRequest(HttpContext context)
{
var sw = Stopwatch.StartNew();
var guid = string.Empty;
try
{
var path = context.Request.Url.AbsolutePath;
if (path != "/api")
{
throw new Exception("path not support");
}
if (context.Request.InputStream == null)
{
throw new ArgumentException("input not support");
}
string jsonReq;
using (var stream = new StreamReader(context.Request.InputStream, Encoding.UTF8))
{
jsonReq = stream.ReadToEnd();
}
if (string.IsNullOrEmpty(jsonReq))
{
throw new ArgumentException("input not support");
}
// HTML编码以及SQL特殊字符串转义
jsonReq = TranslateReq(jsonReq);
XHttpRequest request = JsonHelper.JsonDeserialize <XHttpRequest>(jsonReq);
if (request == null)
{
throw new ArgumentException("input not support");
}
request.TS = DateTime.UtcNow.Ticks;
guid = request.G;
HttpContext.Current.Items.Add("jsonReq", jsonReq);
XHttpResponse response = ServiceEngine.Handler(request, context);
sw.Stop();
response.Tt = sw.ElapsedMilliseconds;
response.G = guid;
context.Response.Write(JsonHelper.JsonSerializer(response));
}
catch (MethodAccessException ex)
{
sw.Stop();
context.Response.Write(JsonHelper.JsonSerializer(XHttpResponse.Exception(sw.ElapsedMilliseconds, guid, (int)ServiceResultStatus.InvalidParameter, ex.Message)));
Logger.Error("{3}:{0},{1} {2}", guid, ex.Message, ex.StackTrace, WebHelper.GetIP());
}
catch (ArgumentException ex)
{
sw.Stop();
context.Response.Write(JsonHelper.JsonSerializer(XHttpResponse.Exception(sw.ElapsedMilliseconds, guid, (int)ServiceResultStatus.InvalidParameter, ex.Message)));
Logger.Error("{3}:{0},{1} {2}", guid, ex.Message, ex.StackTrace, WebHelper.GetIP());
}
catch (Exception ex)
{
sw.Stop();
context.Response.Write(JsonHelper.JsonSerializer(XHttpResponse.Exception(sw.ElapsedMilliseconds, guid, (int)ServiceResultStatus.Error, ex.Message)));
Logger.Error("{2}:{0},{1}", guid, ex.Message, "");
}
}
public TransferFileInfo PushBinaryFileInfo([FromBody] TransferFileInfo fileInfo, byte[] binary)
{
return(ServiceEngine.PushBinaryFileInfo(fileInfo, binary));
}
public byte[] GetBinaryFile([FromBody] TransferFileInfo fileInfo)
{
return(ServiceEngine.GetBinaryFile(fileInfo));
}
public UserService(
ServiceEngine serviceEngine,
BaseMssqlRepository <Domain.Mssql.Poco.User, UserModel> mssqlRepository) : base(serviceEngine)
{
this._mssqlRepository = mssqlRepository;
}
private void OnEnable()
{
script = target as ServiceEngine;
}
public JsonResult Push([FromBody] InEntity content)
{
return(ServiceEngine.InvokeMethod(content.ServiceCode, content.CurrentUserId, content.AccessToken, content.CurrentSendParameter));
}
public JsonResult Get(string ServiceCode,
string CurrentUserId, string CurrentToken, string CurrentSendParameter)
{
return(ServiceEngine.InvokeMethod(ServiceCode, CurrentUserId, CurrentToken, CurrentSendParameter));
}
public System.IO.Stream GetTemplate(string format, string callback, string table_name)
{
var dt = GetTemplate(table_name);
return(ServiceEngine.GetServiceStream(format, callback, dt, null));
}
