コード例 #1
0
        public async Task <IDictionary <Id, Tuple <Todo, Id> > > Handle(DeleteTodosCommand request, CancellationToken cancellationToken)
        {
            var idList = request.TodoIds
                         .Select(x => (Guid)x)
                         .ToList();
            var todosToDelete = await _items
                                .Where(x => idList.Contains(x.Id))
                                .ToListAsync();

            foreach (var todo in todosToDelete)
            {
                _unitOfWork.Remove <TodoEntity>(todo.Id);
            }

            await _unitOfWork.SaveChangesAsync();

            return(todosToDelete
                   .ToDictionary(x => (Id)x.Id, x => Tuple.Create(x.ToModel(), (Id)x.AssignedUserId)));
        }
コード例 #2
0
        public Mutation(IHttpContextAccessor accessor)
        {
            Field <TodoType, KeyValuePair <Id, Tuple <Todo, Id> > >()
            .Name("createTodo")
            .Argument <NonNullGraphType <AddTodoInputType> >("todo", "Todo input.")
            .ResolveAsync(async context =>
            {
                var mediator = accessor.GetMediator();
                var input    = context.GetArgument <AddTodoInput>("todo");

                if (string.IsNullOrEmpty(input.Name))
                {
                    context.Errors.Add(new ExecutionError("Name should not be empty")
                    {
                        Code = "EmptyName"
                    });
                }
                if (context.Errors.Any())
                {
                    return(new KeyValuePair <Id, Tuple <Todo, Id> >(null, null));
                }
                var request = input.ToCommand();
                var result  = await mediator.Send(request);
                return(result.Single());
            });

            Field <TodoType, KeyValuePair <Id, Tuple <Todo, Id> > >()
            .Name("updateTodo")
            .Argument <NonNullGraphType <UpdateTodoInputType> >("todo", "Todo input.")
            .ResolveAsync(async context =>
            {
                var mediator = accessor.GetMediator();
                var input    = context.GetArgument <UpdateTodoInput>("todo");

                if (string.IsNullOrEmpty(input.Name))
                {
                    context.Errors.Add(new ExecutionError("Name should not be empty")
                    {
                        Code = "EmptyName"
                    });
                }
                if (input.Id == Guid.Empty)
                {
                    context.Errors.Add(new ExecutionError("Id should not be empty")
                    {
                        Code = "EmptyId"
                    });
                }
                if (context.Errors.Any())
                {
                    return(new KeyValuePair <Id, Tuple <Todo, Id> >(null, null));
                }
                var request = input.ToCommand();

                var currentItemsRequest = new GetTodosListRequest
                {
                    SpecifiedIds = request.Updates.Keys
                };
                var oldTodos     = await mediator.Send(currentItemsRequest);
                request.OldTodos = oldTodos;

                var todoContext = context.Arguments["todo"] as Dictionary <string, object>;

                if (!todoContext.ContainsKey("description"))
                {
                    var oldItem = oldTodos[input.Id].Item1;
                    request.Updates[input.Id].Item1.Description = oldItem.Description;
                }

                var result = await mediator.Send(request);
                return(result.Single());
            });

            Field <TodoType, KeyValuePair <Id, Tuple <Todo, Id> > >()
            .Name("deleteTodo")
            .Argument <NonNullGraphType <IdGraphType>, Guid>("Id", "Todo id.")
            .ResolveAsync(async context =>
            {
                var mediator = accessor.GetMediator();
                var id       = context.GetArgument <Guid>("id");
                var command  = new DeleteTodosCommand
                {
                    TodoIds = new [] { (Id)id }
                };
                var result = await mediator.Send(command);
                return(result.Single());
            });

            Field <UserType, KeyValuePair <Id, User> >()
            .Name("signIn")
            .Argument <NonNullGraphType <StringGraphType> >("token", "Google token.")
            .ResolveAsync(async context =>
            {
                var mediator = accessor.GetMediator();
                var input    = context.GetArgument <string>("token");
                var command  = new SignInCommand
                {
                    Token = input
                };
                var result = await mediator.Send(command);
                return(result.Single());
            });
        }