private IGraphQlRepository GetConnectionEdgeRepository()
 {
     if (_connectionEdgeRepository == null)
     {
         _connectionEdgeRepository = _graphQlRepositoryProvider.GetRepository <ConnectionEdge>();
     }
     return(_connectionEdgeRepository);
 }
Esempio n. 2
0
        public ConnectionEdgeHandlerTests()
        {
            _graphQlRepositoryProvider = Substitute.For <IGraphQlRepositoryProvider>();
            _connectionEdgeRepository  = Substitute.For <IGraphQlRepository>();

            _graphQlRepositoryProvider.GetRepository <ConnectionEdge>().Returns(_connectionEdgeRepository);

            _connectionEdgeHandler = new ConnectionEdgeHandler(_graphQlRepositoryProvider, new ConnectionEdgeResolver(), Substitute.For <ILogger>());
        }
Esempio n. 3
0
        private async Task <TSource> InternalDeleteAsync <TSource>(IResolveFieldContext <object> context, TSource item) where TSource : class
        {
            try
            {
                IGraphRequestContext ctx = context.GetGraphRequestContext();

                await TransformObject(item, ctx, MutationActions.Delete);

                var mutationActionItem = new MutationActionItem <TSource>
                {
                    Action             = MutationActions.Delete,
                    RequestContext     = ctx,
                    Item               = item,
                    RepositoryProvider = _graphQlRepositoryProvider
                };

                var cloned = item.Clone();

                await _mutationActionsProvider.HandlePreActions(mutationActionItem);

                await _graphQlRepositoryProvider.GetRepository <TSource>().DeleteAsync(item, ctx);

                await _mutationActionsProvider.HandlePostActions(mutationActionItem);

                return(cloned);
            }
            catch (Exception e)
            {
                _logger.LogError(e, "An error has occured while performing a delete operation.");
                throw;
            }
        }
        private async Task InternalDeleteAsync <TSource>(ResolveFieldContext <object> context, TSource item) where TSource : class
        {
            try
            {
                IGraphRequestContext ctx = context.UserContext as IGraphRequestContext;

                await _connectionEdgeHandler.RemoveEdgeConnections(item, ctx);

                await _graphQlRepositoryProvider.GetRepository <TSource>().DeleteAsync(item, ctx);

                if (_searchMappedModels.TryGetMappedSearchType <TSource>(out var mappedSearchType))
                {
                    var mappedInstance = _searchMappedModels.CreateInstanceFromMap(item);
                    await _graphQlRepositoryProvider.GetRepository(mappedSearchType)
                    .DeleteAsync(mappedSearchType, mappedInstance, ctx);
                }
            }
            catch (Exception e)
            {
                _logger.LogError(e, "An error has occured while performing a delete operation.");
                throw;
            }
        }