private void HandleContextMenuInvoked(object sender, MouseEventArgs e) { if (!IsHandleCreated || !Visible) { return; } if (_jetListView.IsColumnHeaderAt(e.X, e.Y)) { if (_headerContextMenu != null) { _headerContextMenu.Show(this, new Point(e.X, e.Y)); } } else if (_showContextMenu) { IActionContext actionContext = _contextProvider.GetContext(ActionContextKind.ContextMenu); if (_jetListView.GetNodeAt(e.X, e.Y) == null) { ActionContext context = actionContext as ActionContext; if (context != null) { context.SetSelectedResources(Core.ResourceStore.EmptyResourceList); } } Core.ActionManager.ShowResourceContextMenu(actionContext, this, e.X, e.Y); } }
private static void RunTest(IContextProvider contextProvider) { List <Contact> contacts = new List <Contact>(); var ctx = contextProvider.GetContext(); contacts = ctx.Contacts.ToList(); foreach (var contact in contacts.Take(2000)) { ctx = contextProvider.GetContext(); // get a copy of the contact - either new or cached depending on our context provider var localContact = ctx.Contacts.Single(c => c.ContactId == contact.ContactId); // create a new account Account acc = new Account() { Name = contact.Name }; // link contact and account localContact.Account = acc; // save changes ctx.SaveChanges(); } }
/// <summary> /// Deserializes the NQuads into a typed model /// </summary> /// <typeparam name="T">destination entity model type</typeparam> /// <param name="nQuads">RDF data in NQuads.</param> public T Deserialize <T>(string nQuads) { var jsonLdObject = JsonLdProcessor.FromRDF(nQuads); var jsonLdContext = _contextProvider.GetContext(typeof(T)); if (jsonLdContext == null) { throw new ContextNotFoundException(typeof(T)); } return(JsonLdProcessor.Compact(jsonLdObject, jsonLdContext, new JsonLdOptions()).ToObject <T>(_jsonSerializer)); }
public void Update(IContextProvider contextProvider) { ContextProvider = contextProvider; var parameter = ContextProvider.GetContext(); Update(parameter); }
public void GenerateFakeUsers() { using (var context = _provider.GetContext <UserModel>()) { context.AddManyAsync(GetUsers()); } }
/// <summary> /// Registers the Disqus client resources to be rendered in defined areas. /// </summary> /// <param name="requiredResources">The required resources.</param> public void RegisterResources(IRequiredClientResourceList requiredResources) { var renderingContext = _contextProvider.GetContext(); if (!renderingContext.IsInPreviewMode && !renderingContext.IsInEditMode) { return; } if (renderingContext.IsInEditMode) { requiredResources.Require("duk-disqus.EditMode"); // Hack: output text in Edit mode to indicate thread placeholders that were not used by Disqus. // For example, it can be a case when there are several placeholders on a page. // We have to inject inline CSS here to be able to provide localized message text. var inlineStyle = string.Format(CultureInfo.InvariantCulture, "div#disqus_thread:empty:before {{content: '{0}';}}", _localizationService.GetString("/disqus/ui/rendering/severalthreadsonpage")); requiredResources.RequireStyleInline(inlineStyle, "duk-disqus.EditMode.severalThreadsIndicator", null); } // Inject the following styles for Edit and Preview modes requiredResources.Require("duk-disqus.PreviewMode"); var httpContext = HttpContext.Current; if (httpContext != null) { httpContext.Items[ResourcesAreRegisteredKey] = true; } }
public async Task <IActionResult> List([FromRoute] string dbId) { var dbContext = _contextProvider.GetContext(dbId); var list = await dbContext.Table.ToListAsync(); return(Ok(list)); }
public void Process(IContextProvider contextProvider) { var context = contextProvider.GetContext(); if (Time.time >= _nextUpdateTime) { _nextUpdateTime = Time.time + brain.settings.updateInterval; if (AIDebuggingHook.currentDebuggedContextProvider == contextProvider) { AIDebuggingHook.debugger = AIDebuggingHook.currentDebugger; AIDebuggingHook.debugger.FrameReset(); } var bestQualifier = _brain.root.Select(context); AIDebuggingHook.debugger = null; if (_currentAction != null && (bestQualifier == null || bestQualifier.action != _currentAction)) { _currentAction.Stop(context); } if (bestQualifier != null) { _currentAction = bestQualifier.action; } } if (_currentAction != null) { _currentAction.Execute(context); } }
public void Deserializing_quads_should_throw_when_context_isnt_found() { // given A.CallTo(() => _provider.GetContext(typeof(Person))).Returns(null); // when _serializer.Deserialize <Person>(string.Empty); }
private IActionContext GetContext() { if (_contextProvider == null) { return(new ActionContext(ActionContextKind.Toolbar, null, null)); } return(_contextProvider.GetContext(ActionContextKind.Toolbar)); }
public async Task <IActionResult> GetAll() { IEnumerable <TstModel> result; using (var context = _contextProvider.GetContext <TstModel>()) { result = await context.GetAllAsync(); } return(Ok(result)); }
/// <summary> /// Executes the AI. Typically this is called by whatever manager controls the AI execution cycle. /// </summary> public void Execute() { IAIContext context = _contextProvider.GetContext(_ai.id); var action = _ai.Select(context); bool finalActionFound = false; while (!finalActionFound) { //While we could treat all connectors the same, most connectors will not have anything to execute, so this way we save the call to Execute. var composite = action as ICompositeAction; if (composite == null) { var connector = action as IConnectorAction; if (connector == null) { finalActionFound = true; } else { action = connector.Select(context); } } else { //For composites that also connect, we execute the child actions before moving on. //So action is executed and then reassigned to the selected action if one exists. if (composite.isConnector) { action.Execute(context); action = composite.Select(context); } else { finalActionFound = true; } } } if (_activeAction != null && !object.ReferenceEquals(_activeAction, action)) { _activeAction.Terminate(context); _activeAction = action as IRequireTermination; } else if (_activeAction == null) { _activeAction = action as IRequireTermination; } if (action != null) { action.Execute(context); } }
/// <summary> /// Provides the action execution context by quering the supplied context provider. /// </summary> public IActionContext GetContext(ActionContextKind kind) { // Relay context acquision to the supplied context provider, if specified if (_contextprovider != null) { return(_contextprovider.GetContext(kind)); } // Generate an empty context, if not set return(new ActionContext(kind, this, null)); }
public async Task Invoke(HttpContext httpContext) { Context context = contextProvider.GetContext(); if (context == null) { context = new Context(); contextProvider.SetContext(context); } await requestDelegate.Invoke(httpContext); }
private object CreateExecutionContext() { try { return(_contextProvider.GetContext()); } catch (Exception e) { throw new InvalidOperationException($"Context initialization failed: {e.Message}", e); } }
public IActionContext GetContext(ActionContextKind kind) { if (_lastActivePaneData != null) { IContextProvider provider = _lastActivePaneData.Pane as IContextProvider; if (provider != null) { return(provider.GetContext(kind)); } } return(null); }
public static IServiceContext Create(IContextProvider provider, IServiceProfile profile) { if (provider.GetContext <ILightweightContext>() != null) { throw new InvalidOperationException($"Only one instance of '{nameof(ILightweightProfile)}' is allowed."); } // ReSharper disable once UseNegatedPatternMatching // ReSharper disable once SuspiciousTypeConversion.Global var lightweightProfile = (ILightweightProfile)profile; return(lightweightProfile == null ? null : new LightweightContext(provider, lightweightProfile)); }
private static void Execute(Action cb, TService service, MethodInfo methodInfo, object[] args, TPolicyProvider provider, IContextProvider contextProvider) { var context = contextProvider.GetContext(typeof(TService), service, methodInfo, args); var policy = provider.GetSyncPolicy(context); if (policy == null) { cb(); return; } policy.Execute(ctx => cb(), context); }
protected override bool HandleContextMenu(JetListViewNode node, int x, int y) { if (_contextProvider != null) { IResource res = (IResource)node.Data; ICustomColumn col = GetCustomColumn(res); IActionContext context = _contextProvider.GetContext(ActionContextKind.ContextMenu); if (col.ShowContextMenu(context, OwnerControl, new Point(x, y))) { return(true); } } return(false); }
private static async Task <object> ExecuteAsync(Func <Task <object> > cb, TService service, MethodInfo methodInfo, object[] args, TPolicyProvider provider, IContextProvider contextProvider) { var context = contextProvider.GetContext(typeof(TService), service, methodInfo, args); var policy = provider.GetAsyncPolicy(context); if (policy == null) { return(await cb()); } var result = await policy.ExecuteAsync(ctx => cb(), context); return(result); }
private static object Execute(Func <object> cb, TService service, MethodInfo methodInfo, object[] args, TPolicyProvider provider, IContextProvider contextProvider) { var context = contextProvider.GetContext(typeof(TService), service, methodInfo, args); var policy = provider.GetSyncPolicy(context); if (policy == null) { return(cb()); } var result = policy.Execute(ctx => cb(), context); return(result); }
public override void OnActionExecuted(ActionExecutedContext context) { if (context.Result is ObjectResult) { object resultObject = ((ObjectResult)context.Result).Value; if (resultObject is BaseResponse) { IContextProvider contextProvider = context.HttpContext.RequestServices.GetRequiredService <IContextProvider>(); ((BaseResponse)resultObject).Context = contextProvider.GetContext(); } } base.OnActionExecuted(context); }
public void ExecuteAction(IServiceProvider serviceProvider, ref object request, ref BaseResponse response) { if (serviceProvider == null) { throw new JMException("ContextNotFound"); } else { IContextProvider contextProvider = serviceProvider.GetService(typeof(IContextProvider)) as IContextProvider; if (contextProvider == null || contextProvider.GetContext() == null) { throw new JMException("ContextNotFound"); } } }
public string Post([FromBody] RequestPayload requestMessage) { try { contextProvider.SetContext(requestMessage.Context); FlowConfiguration configuration = flowConfigurationProvider.GetConfiguration(requestMessage.Action); ValidationHelper.ExecuteValidations(configuration, requestMessage.Request); BaseResponse response = flowProvider.ExecuteFlow(serviceProvider, requestMessage.Action, requestMessage.Request); ResponsePayload responseMessage = new ResponsePayload { Context = contextProvider.GetContext(), Response = response }; return(responseMessage.ToJson()); } catch (Exception e) { try { JMResult result = serviceProvider.GetRequiredService <IExceptionHandler>().HandleException(e); Context context = contextProvider.GetContext(); context.ActiveResult = result; return(new ResponsePayload { Context = context, Response = null }.ToJson()); } catch (Exception innerException) { DefaultLogger.Error(innerException); return(new ResponsePayload().ToJson()); } } }
public async Task <UserModel> GetUserByLoginAsync(string login) { try { using (var context = _contextProvider.GetContext <UserModel>()) { return(await context.GetSingleAsync(x => x.UserLogin == login)); } } catch (Exception ex) { //#TODO log throw new ArgumentException("User not found"); } }
/// <summary> /// Intercept the invocation /// </summary> /// <param name="invocation"></param> public void Intercept(_IInvocation invocation) { if (!invocation.Method.IsVirtual || invocation.Method.IsFinal) { invocation.Proceed(); return; } var methodExecutingContext = new MethodExecutingContext { InvocationContext = _contextProvider.GetContext(), MethodInfo = invocation.Method, Invocation = invocation }; var attributes = GetInvocationMethodFilterAttributes(invocation, methodExecutingContext.InvocationContext); if (attributes.Any(a => a is NoInterceptAttribute)) { invocation.Proceed(); return; } var filterAttributes = attributes.OfType <MethodFilterAttribute>().OrderBy(x => x.Order).ToList(); var isAsync = typeof(Task).IsAssignableFrom(invocation.Method.ReturnType); if (isAsync) { if (invocation.Method.ReturnType.IsGenericType && invocation.Method.ReturnType.GetGenericTypeDefinition() == typeof(Task <>)) { var taskResultType = invocation.Method.ReturnType.GetGenericArguments()[0]; var mInfo = _handleAsyncWithTypeMethod.MakeGenericMethod(taskResultType); filterAttributes.Add(new InvocationAttribute(invocation, taskResultType)); invocation.ReturnValue = mInfo.Invoke(this, new object[] { filterAttributes, methodExecutingContext, taskResultType }); } else { filterAttributes.Add(new InvocationAttribute(invocation)); invocation.ReturnValue = HandleAsync(filterAttributes, methodExecutingContext); } } else { filterAttributes.Add(new InvocationAttribute(invocation)); HandleSync(filterAttributes, methodExecutingContext); } }
public BaseResponse ExecuteFlow(IServiceProvider serviceProvider, string actionName, object request) { FlowConfiguration flowConfiguration = flowConfigurationProvider.GetConfiguration(actionName); contextProvider.GetContext().ActiveFlowConfiguration = flowConfiguration; Type responseType = Type.GetType(flowConfiguration.ResponseIdentifier); BaseResponse response = Activator.CreateInstance(responseType) as BaseResponse; foreach (FlowItemDefinition flowItem in flowExecutionConfigurationProvider.GetActiveConfiguration().FlowItems) { Type flowItemType = Type.GetType(flowItem.TypeIdentifier); BaseFlowItem flowItemInstance = Activator.CreateInstance(flowItemType) as BaseFlowItem; flowItemInstance.ExecuteFlow(serviceProvider, ref request, ref response); } return(response); }
public IActionContext GetContext(ActionContextKind kind) { ActionContext context; if (_contextProvider != null) { context = (ActionContext)_contextProvider.GetContext(kind); } else { context = new ActionContext(kind, this, null); context.SetCommandProcessor(this); } context.SetSelectedText(SelectedRtf, SelectedText, TextFormat.Rtf); return(context); }
public LoginResponse Post([FromBody] LoginRequest request) { LoginResponse response = authenticationProvider.Authenticate(request); if (response.Result != Entities.UserManagement.LoginResultEnum.Successful) { throw new JMException(response.Result.ToString()); } else { //issue token response.Token = tokenProvider.IssueToken(request.Username.ToPlainString()); Context context = contextProvider.GetContext(); context.User = response.User; contextProvider.SetContext(context); } return(response); }
/// <summary> /// Writes the JSON representation of the object. /// </summary> /// <param name="writer">The <see cref="T:Newtonsoft.Json.JsonWriter" /> to write to.</param> /// <param name="value">The value.</param> /// <param name="serializer">The calling serializer.</param> public override void WriteJson(JsonWriter writer, [AllowNull] object value, JsonSerializer serializer) { writer.WriteStartObject(); var context = _contextProvider.GetContext(value.GetType()); if (context != null) { writer.WritePropertyName("@context"); serializer.Serialize(writer, context); } var types = GetTypes(value.GetType()); if (types.Any()) { writer.WritePropertyName("@type"); writer.WriteStartArray(); foreach (var type in types) { writer.WriteValue(type); } writer.WriteEndArray(); } var objectContract = (JsonObjectContract)serializer.ContractResolver.ResolveContract(value.GetType()); foreach (var property in objectContract.Properties) { var propVal = property.ValueProvider.GetValue(value); if (propVal != null) { writer.WritePropertyName(property.PropertyName); serializer.Serialize(writer, propVal); } } writer.WriteEndObject(); }