public MockVMController(IVMFactory vmFactory) : this()
{
_vmController = new VMController((connectionId, vmId, vmData) =>
{
_response.Handler(connectionId, vmId, vmData);
OnResponse?.Invoke(this, vmData);
}, vmFactory);
}
public LoginVMFactory(
IAuthService authService,
INavigator navigator,
IVMFactory <AppointmentsVM> appointmentVMFactory)
{
_authService = authService;
_navigator = navigator;
_appointmentVMFactory = appointmentVMFactory;
}
public InvocationTransactionPersister(
IVMFactory vmFactory,
IBinarySerializer binarySerializer,
IContainer container)
{
_vmFactory = vmFactory ?? throw new ArgumentNullException(nameof(vmFactory));
_binarySerializer = binarySerializer ?? throw new ArgumentNullException(nameof(binarySerializer));
_container = container ?? throw new ArgumentNullException(nameof(container));
}
public void Initialize()
{
var options = Substitute.For <IOptions <ms.MemoryCacheOptions> >();
options.Value.Returns(new ms.MemoryCacheOptions());
var memoryCache = new MemoryCacheAdapter(new ms.MemoryCache(options));
_vmFactory = new VMFactory(memoryCache, new VMTypesAccessor());
}
public void TestInitialize()
{
Assert.IsTrue(NeoVM.IsLoaded || NeoVM.TryLoadLibrary(NeoVM.DefaultLibraryName, out var error));
_VMFactory = new NeoVM();
//Console.WriteLine("Native Library Info");
//Console.WriteLine(" Path: " + NeoVM.LibraryPath);
//Console.WriteLine(" Version: " + NeoVM.LibraryVersion);
//Console.WriteLine("");
}
public static string GetInitialStates(IVMFactory vmFactory, ref string path, Type entryVMType)
{
string result = null;
try
{
using (var vmController = new VMController((arg1, arg2, arg3) => Task.CompletedTask, vmFactory))
{
// Traverse the routing path to get initial states of all the view models involved.
var vmStates = new List <string>();
if (!Path.HasExtension(path))
{
var viewData = new RoutingViewData(path, null, entryVMType);
RoutableExtension.Route(ref viewData, out object vm);
while (vm != null)
{
object vmArgs = null;
if (vm is IRoutable routable)
{
// If at the end of the path and the view model has a default route template (blank url pattern),
// append a slash to the path to ensure it's correctly routed.
if (path.Trim('/').Length > 0 && string.Compare(viewData.UrlPath, viewData.Root, true) == 0 && routable.RoutingState.Templates.Any(i => i.UrlPattern == ""))
{
path += "/";
}
// Determine the "RoutingState.Origin" property value and pass it as argument to the view model
// associated with the current path to set its initial state correctly.
string args = routable.InitArgs(viewData);
Match match = Regex.Match(args, "'RoutingState.Origin':\\s*'(.*?)'");
if (match.Success)
{
vmArgs = JsonConvert.DeserializeObject($"{{{match.Value}}}");
}
}
string vmName = vm.GetType().Name;
vmStates.Add($"\"{vmName}\":{vmController.GetInitialState(vmName, vmArgs)}");
// Traverse the next path.
RoutableExtension.Route(ref viewData, out vm);
}
result = $"{{{string.Join(",", vmStates)}}}";
}
return(result);
}
}
catch (Exception ex)
{
Logger.LogError($"Failed to get SSR initial states: {ex.Message}");
return(null);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="logBag">Log bag</param>
/// <param name="logger">Logger</param>
/// <param name="log">Log</param>
/// <param name="vmFactory">VM Factory</param>
/// <param name="consoleHandler">Console handler</param>
public PromptDebugController
(
ILogBag logBag,
Core.Logging.ILogger <Prompt> logger, ILoggerFactoryExtended log,
IVMFactory vmFactory, IConsoleHandler consoleHandler
)
{
_logs = logBag;
_log = log;
_logger = logger;
_vmFactory = vmFactory;
_consoleHandler = consoleHandler;
}
public LoginCommand(
LoginVM loginVM,
IAuthService authService,
INavigator navigator,
IVMFactory<AppointmentsVM> appointmentVMFactory)
{
_loginVM = loginVM;
_authService = authService; ;
_navigator = navigator;
_appointmentVMFactory = appointmentVMFactory;
_loginVM.PropertyChanged += ErrorsChanged;
}
public RootVMFactory(
IVMFactory <LoginVM> loginFactory,
IVMFactory <HomeVM> homeFactory,
IVMFactory <CustomersVM> customersFactory,
IVMFactory <AppointmentsVM> appointmentsFactory,
IVMFactory <AddressesVM> addressesFactory)
{
_loginFactory = loginFactory;
_homeFactory = homeFactory;
_customersFactory = customersFactory;
_appointmentsFactory = appointmentsFactory;
_addressesFactory = addressesFactory;
}
public IActionResult Get()
{
var accounts = _repo.GetAccountsByUser(User.Identity.Name);
ICollection <AccountViewModel> accountsVM = new List <AccountViewModel>();
_vmFactory = new VMFactory(_mapper);
foreach (Account account in accounts)
{
var accountVM = _vmFactory.CreateAccountVM(account, Url);
}
return(Ok(accountsVM));
}
public async Task <string> Request_VM(
string vmId,
[FromQuery] string vmArg,
[FromServices] IVMFactory vmFactory,
[FromServices] IHubServiceProvider hubServiceProvider,
[FromServices] IVMServiceScopeFactory serviceScopeFactory,
[FromServices] IHubPipeline hubPipeline,
[FromServices] IPrincipalAccessor principalAccessor
)
{
var taskCompletionSource = new TaskCompletionSource <string>(TaskCreationOptions.RunContinuationsAsynchronously);
Task responseVM(string arg1, string arg2, string arg3)
{
taskCompletionSource.TrySetResult(arg3);
return(Task.CompletedTask);
}
var vmController = new VMController(responseVM, vmFactory, serviceScopeFactory.CreateScope())
{
ResponseVMFilter = CreateRespondingVMFilter(hubPipeline, vmId, vmArg)
};
var httpCallerContext = InitializeContext(vmController, hubServiceProvider, principalAccessor);
var connectionId = httpCallerContext.ConnectionId;
try
{
var hubContext = new DotNetifyHubContext(httpCallerContext, nameof(Request_VM), vmId, vmArg, BuildHeaders(), httpCallerContext.User);
vmController.RequestVMFilter = CreateVMFilter(hubContext, hubPipeline);
await hubPipeline.RunMiddlewaresAsync(hubContext, async ctx =>
{
await vmController.OnRequestVMAsync(connectionId, ctx.VMId, ctx.Data);
vmController.Dispose();
});
}
catch (Exception ex)
{
var finalEx = await hubPipeline.RunExceptionMiddlewareAsync(httpCallerContext, ex);
if (finalEx is OperationCanceledException == false)
{
taskCompletionSource.TrySetResult(DotNetifyHub.SerializeException(finalEx));
}
}
return(await taskCompletionSource.Task);
}
public MockVMController(IVMFactory vmFactory, string hubConnectionId = null, Action <string, string> responseDelegate = null) : this()
{
_connectionId = hubConnectionId ?? $"conn{IdCount++}";
_vmController = new VMController((connectionId, vmId, vmData) =>
{
_response.Handler(connectionId, vmId, vmData);
if (responseDelegate != null)
{
responseDelegate(connectionId, vmData);
}
else
{
OnResponse?.Invoke(this, vmData);
}
}, vmFactory);
}
/// <summary>
/// Execute this test
/// </summary>
/// <param name="factory">Factory</param>
/// <param name="ut">Test</param>
public void ExecuteTest(IVMFactory factory, VMUT ut)
{
foreach (var test in ut.Tests)
{
// Arguments
var storages = new ManualStorage();
var interopService = new InteropService();
var contracts = new ManualContracts();
var state = new StateMachine
(
null, null, null, contracts,
storages, interopService, null, null, null, test.Trigger
);
var args = new ExecutionEngineArgs()
{
Trigger = test.Trigger,
InteropService = interopService,
Logger = new ExecutionEngineLogger(ELogVerbosity.StepInto),
ScriptTable = contracts,
};
var log = new StringBuilder();
var logBag = new List <string>();
var notBag = new List <JToken>();
interopService.OnLog += (sender, e) =>
{
logBag.Add(e.Message);
};
interopService.OnNotify += (sender, e) =>
{
notBag.Add(ItemToJson(e.State));
};
args.Logger.OnStepInto += (context) =>
{
log.AppendLine(context.InstructionPointer.ToString("x6") + " - " + context.NextInstruction);
};
interopService.OnSysCall += (o, e) =>
{
// Remove last line
log.Remove(log.Length - Environment.NewLine.Length, Environment.NewLine.Length);
log.AppendLine($" [{e.MethodName} - {e.Result}]");
};
// Script table
if (test.ScriptTable != null)
{
foreach (var script in test.ScriptTable)
{
var contract = new Contract()
{
Code = new Code()
{
Script = script.Script,
ScriptHash = script.Script.ToScriptHash(),
Metadata = ContractMetadata.NoProperty
}
};
if (script.HasDynamicInvoke)
{
contract.Code.Metadata |= ContractMetadata.HasDynamicInvoke;
}
if (script.HasStorage)
{
contract.Code.Metadata |= ContractMetadata.HasStorage;
}
if (script.Payable)
{
contract.Code.Metadata |= ContractMetadata.Payable;
}
contracts.Add(contract.ScriptHash, contract);
}
contracts.Commit();
}
// Create engine
using (var engine = factory.Create(args))
{
engine.GasAmount = ulong.MaxValue;
engine.LoadScript(test.Script);
// Execute Steps
if (test.Steps != null)
{
foreach (var step in test.Steps)
{
// Actions
log.Clear();
logBag.Clear();
notBag.Clear();
foreach (var run in step.Actions)
{
switch (run)
{
case VMUTActionType.Execute: engine.Execute(); break;
case VMUTActionType.StepInto: engine.StepInto(); break;
case VMUTActionType.StepOut: engine.StepOut(); break;
case VMUTActionType.StepOver: engine.StepOver(); break;
case VMUTActionType.Clean: engine.Clean(); break;
}
}
// Review results
var add = string.IsNullOrEmpty(step.Name) ? "" : "-" + step.Name;
AssertResult(engine, step.State, logBag, notBag, $"{ut.Category}-{ut.Name}{add}: ");
}
}
}
}
}
/// <summary> /// Execute this test /// </summary> /// <param name="factory">Factory</param> /// <param name="json">Json</param> public void ExecuteTest(IVMFactory factory, string json) => ExecuteTest(factory, json.JsonToVMUT());
/// <summary>
/// Constructor.
/// </summary>
/// <param name="vmResponse">Function invoked by the view model to provide response back to the client.</param>
/// <param name="serviceScope">Dependency injection service scope.</param>
public VMController(VMResponseDelegate vmResponse, IVMFactory vmFactory, IVMServiceScope serviceScope = null) : this()
{
_vmResponse = vmResponse ?? throw new ArgumentNullException(nameof(vmResponse));
_vmFactory = vmFactory;
_serviceScope = serviceScope;
}
public void Initialize()
{
_vmFactory = new VMFactory(new MemoryCache());
}
public async Task <string> Update_VM(
string vmId,
[FromQuery] string vmArg,
[FromBody] Dictionary <string, object> vmData,
[FromServices] IVMFactory vmFactory,
[FromServices] IHubServiceProvider hubServiceProvider,
[FromServices] IVMServiceScopeFactory serviceScopeFactory,
[FromServices] IHubPipeline hubPipeline,
[FromServices] IPrincipalAccessor principalAccessor)
{
var taskCompletionSource1 = new TaskCompletionSource <string>();
var taskCompletionSource2 = new TaskCompletionSource <string>();
var vmController = new VMController((arg1, arg2, arg3) =>
{
if (!taskCompletionSource1.TrySetResult(arg3))
{
taskCompletionSource2.TrySetResult(arg3);
}
}, vmFactory, serviceScopeFactory.CreateScope())
{
ResponseVMFilter = CreateRespondingVMFilter(hubPipeline, vmId, vmData)
};
var httpCallerContext = InitializeContext(vmController, hubServiceProvider, principalAccessor);
var connectionId = httpCallerContext.ConnectionId;
try
{
var hubContext = new DotNetifyHubContext(httpCallerContext, nameof(Request_VM), vmId, vmArg, BuildHeaders(), httpCallerContext.User);
vmController.RequestVMFilter = CreateVMFilter(hubContext, hubPipeline);
hubPipeline.RunMiddlewares(hubContext, ctx =>
{
vmController.OnRequestVM(connectionId, ctx.VMId, ctx.Data);
return(Task.CompletedTask);
});
}
catch (Exception ex)
{
var finalEx = hubPipeline.RunExceptionMiddleware(httpCallerContext, ex);
if (finalEx is OperationCanceledException == false)
{
taskCompletionSource1.TrySetResult(DotNetifyHub.SerializeException(finalEx));
}
}
await taskCompletionSource1.Task;
try
{
var hubContext = new DotNetifyHubContext(httpCallerContext, nameof(Update_VM), vmId, vmData, BuildHeaders(), httpCallerContext.User);
vmController.UpdateVMFilter = CreateVMFilter(hubContext, hubPipeline);
hubPipeline.RunMiddlewares(hubContext, ctx =>
{
vmController.OnUpdateVM(connectionId, ctx.VMId, ctx.Data as Dictionary <string, object>);
vmController.Dispose();
return(Task.CompletedTask);
});
}
catch (Exception ex)
{
var finalEx = hubPipeline.RunExceptionMiddleware(httpCallerContext, ex);
if (finalEx is OperationCanceledException == false)
{
taskCompletionSource2.TrySetResult(DotNetifyHub.SerializeException(finalEx));
}
}
return(await taskCompletionSource2.Task);
}
public void Initialize()
{
_vmFactory = new VMFactory(new MemoryCache(), new VMTypesAccessor());
}
public ObservableVMCollectionFactory(IVMFactory <TModel, TViewModel> factory)
{
this._factory = factory.CheckForNull();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="memoryCache">Memory cache for storing the view model controllers.</param>
/// <param name="vmFactory">Factory for view models.</param>
/// <param name="serviceScopeFactory">Factory for dependency injection service scope.</param>
public VMControllerFactory(IMemoryCache memoryCache, IVMFactory vmFactory, IVMServiceScopeFactory serviceScopeFactory)
{
_controllersCache = memoryCache ?? throw new ArgumentNullException("No service of type IMemoryCache has been registered.");
_serviceScopeFactory = serviceScopeFactory;
_vmFactory = vmFactory;
}
public WebApiVMControllerFactory(IVMFactory vmFactory, IVMServiceScopeFactory serviceScopeFactory) :
base(_cache, vmFactory, serviceScopeFactory)
{
CacheExpiration = TimeSpan.FromMinutes(20);
}
public EntriesController(ILedgerRepository repo, IMapper mapper, IVMFactory vmFactory)
{
_repo = repo;
_mapper = mapper;
_vmFactory = vmFactory;
}
/// <summary>
/// Add VMShared to model if it is inherited by IHasVMShared
/// </summary>
/// <param name="fac"></param>
/// <param name="shared"></param>
public static void AddShared <type>(this IVMFactory fac, IHasVMShared shared)
{
shared.Shared = (IVMShared)fac.CreateView <type>();
}
