public async Task Deletes_todo()
{
var client = _factory.CreateClient();
EntityId newTodoId;
{
var newTodo = new CreateTodo()
{
Title = "New todo"
};
var postResponse = await client.PostAsJsonAsync("/api/todo", newTodo);
postResponse.EnsureSuccessStatusCode();
newTodoId = await postResponse.Content.ReadFromJsonAsync <EntityId>();
}
{
var postResponse = await client.DeleteAsync($"/api/todo/{newTodoId}");
postResponse.EnsureSuccessStatusCode();
}
{
var response = await client.GetFromJsonAsync <List <TodoItem> >("/api/todo");
Assert.Empty(response);
}
}
public IActionResult CreateTodo(CreateTodo model)
{
int result = 0;
var url = $"{Common.Common.ApiUrl}/todo/createtodo";
HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
httpWebRequest.ContentType = "application/json";
httpWebRequest.Method = "POST";
using (var streamWrite = new StreamWriter(httpWebRequest.GetRequestStream()))
{
var json = JsonConvert.SerializeObject(model);
streamWrite.Write(json);
}
var httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();
using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
var resResult = streamReader.ReadToEnd();
result = int.Parse(resResult);
}
if (result > 0)
{
TempData["Done"] = "Todo create successfully";
}
ModelState.Clear();
ViewBag.VGgroups = ListGroup();
ViewBag.VGgroupid = groupIdC;
return(View(new CreateTodo()
{
}));
}
public void Handle(CreateTodo createTodo)
{
if (State.Name == null)
{
Raise(new TodoCreated(createTodo.Name));
}
}
public async Task Cannot_start_or_finish_deleted_item()
{
var client = _factory.CreateClient();
EntityId newTodoId;
{
var newTodo = new CreateTodo()
{
Title = "New todo"
};
var postResponse = await client.PostAsJsonAsync("/api/todo", newTodo);
postResponse.EnsureSuccessStatusCode();
newTodoId = await postResponse.Content.ReadFromJsonAsync <EntityId>();
}
{
var postResponse = await client.DeleteAsync($"/api/todo/{newTodoId}");
postResponse.EnsureSuccessStatusCode();
}
{
var postResponse = await client.PostAsJsonAsync($"/api/todo/{newTodoId}/finish", "");
Assert.Equal(System.Net.HttpStatusCode.BadRequest, postResponse.StatusCode);
}
{
var postResponse = await client.PostAsJsonAsync($"/api/todo/{newTodoId}/start", "");
Assert.Equal(System.Net.HttpStatusCode.BadRequest, postResponse.StatusCode);
}
}
public GetTodo CreateTodoItem(CreateTodo createTodoItem)
{
var mappedTodoItem = _mapper.Map <TodoItem>(createTodoItem);
_todoStore.CreateTodoItem(mappedTodoItem);
return(_mapper.Map <GetTodo>(mappedTodoItem));
}
static void Main(string[] args)
{
var createTodo = new CreateTodo {
AggregateId = Guid.NewGuid().ToString(), Name = "remote Todo"
};
var complete = new CompleteTodo {
AggregateId = createTodo.AggregateId
};
Remote.Start("127.0.0.1", 12001);
Cluster.Start("MyCluster", new ConsulProvider(new ConsulProviderOptions {
DeregisterCritical = TimeSpan.FromSeconds(1)
}));
EventStream.Instance.Subscribe(x =>
{
Console.WriteLine($"{DateTime.Now} - {x}");
switch (x)
{
case ClusterTopologyEvent e:
e.Statuses.ToList().ForEach(s => Console.WriteLine($" {s.Address}:{s.Port}/{s.MemberId} - Alive:{s.Alive}"));
break;
case EndpointTerminatedEvent e:
Console.WriteLine($" {e.Address} was terminated");
break;
}
});
while (Console.ReadLine() != "stop")
{
Task.Run(async() =>
{
try
{
var pid = await Cluster.GetAsync(createTodo.AggregateId, "Todo");
pid.Tell(createTodo);
pid.Tell(complete);
}
catch (AggregateException ex)
{
Console.WriteLine(ex.Message);
foreach (var innerException in ex.InnerExceptions)
{
Console.WriteLine(innerException.Message);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
});
}
Console.ReadLine();
}
public void DoWork(int versionNumber)
{
var todoItem = new CreateTodo()
{
Value = $"V{versionNumber}. This is a scheduled task that posts every 5 minutes."
};
_todoService.CreateTodoItem(todoItem);
}
static async Task Main(string[] args)
{
// data <- dbcontext <- services <- cmd/webapi/
var optionsBuilder = new DbContextOptionsBuilder <TodosContext>();
optionsBuilder.UseSqlite("Data Source=todos.db");
using var todosContext = new TodosContext(optionsBuilder.Options);
await todosContext.Database.EnsureCreatedAsync();
var todosService = new TodosService(todosContext);
Parser.Default.ParseArguments <ListTodosOptions, CreateTodoOptions>(args)
.WithParsed <ListTodosOptions>(async(listOption) =>
{
var todos = await todosService.GetTodosAsync();
Console.WriteLine(JsonSerializer.Serialize(todos, new JsonSerializerOptions
{
WriteIndented = true
}));
})
.WithParsed <CreateTodoOptions>(async createTodoOption =>
{
var todo = new CreateTodo
{
Title = createTodoOption.Title,
Description = createTodoOption.Description
};
var addedTodo = await todosService.CreateTodoAsync(todo);
Console.WriteLine(JsonSerializer.Serialize(addedTodo, new JsonSerializerOptions
{
WriteIndented = true
}));
});
// Console.WriteLine($"Number of todos = {await todosService.GetCountAsync()}");
// var todo = new CreateTodo
// {
// Title = "get groceries"
// };
// var addedTodo = await todosService.CreateTodoAsync(todo);
// Console.WriteLine(JsonSerializer.Serialize(todo, new JsonSerializerOptions
// {
// WriteIndented = true
// }));
// Console.WriteLine("All todos");
// var todos = await todosService.GetTodosAsync();
// Console.WriteLine(JsonSerializer.Serialize(todos, new JsonSerializerOptions
// {
// WriteIndented = true
// }));
}
public IActionResult Create(TodoViewModel model)
{
var createTodo = new CreateTodo(model.Name, model.Description);
var reply = this.bus.RequestReply <CreateTodo, dynamic>(CreateTodo.Namespace, createTodo);
ViewData["Response"] = reply["response"];
return(View("Index"));
}
public async Task <IActionResult> Post([FromBody] Todo value)
{
value.Id = Guid.NewGuid();
var command = new CreateTodo(value.Id, value.Description);
await _command.Execute(command);
return(Ok(await _query.Execute <GetTodoById, Task <Todo> >(new GetTodoById(value.Id))));
}
public async Task <object> Post(CreateTodo request)
{
var todo = request.ConvertTo <Todo>();
todo.Id = Interlocked.Increment(ref Counter);
Todos.Add(todo);
await ServerEvents.NotifyChannelAsync("todos", "todos.create", todo);
return(new CreateTodoResponse {
Result = todo
});
}
public ActionResult CreateTodoItem([FromBody] CreateTodo todoItem)
{
try
{
var todo = _todoService.CreateTodoItem(todoItem);
return(Created(Request.Path.Value, todo));
}
catch (Exception ex)
{
_logger.LogError(ex, "Unhandled exception occurred (HTTP 500): {0} {2}{3}", Request.Method, Request.Path, Request.QueryString);
return(StatusCode((int)HttpStatusCode.InternalServerError, "Unexpected error occured"));
}
}
public async Task Retrieves_history_of_all_actions()
{
var client = _factory.CreateClient();
var firstTodo = new CreateTodo()
{
Title = "First todo"
};
var firstPostResponse = await client.PostAsJsonAsync("/api/todo", firstTodo);
EntityId firstTodoId = await firstPostResponse.Content.ReadFromJsonAsync <EntityId>();
_factory.Clock.AdvanceSeconds(1);
await client.PostAsJsonAsync($"/api/todo/{firstTodoId}/finish", "");
_factory.Clock.AdvanceSeconds(1);
var secondTodo = new CreateTodo()
{
Title = "Second todo"
};
var secondPostResponse = await client.PostAsJsonAsync("/api/todo", secondTodo);
EntityId secondTodoId = await secondPostResponse.Content.ReadFromJsonAsync <EntityId>();
_factory.Clock.AdvanceSeconds(1);
await client.PostAsJsonAsync($"/api/todo/{firstTodoId}/start", "");
_factory.Clock.AdvanceSeconds(1);
await client.PostAsJsonAsync($"/api/todo/{secondTodoId}/finish", "");
_factory.Clock.AdvanceSeconds(1);
await client.DeleteAsync($"/api/todo/{firstTodoId}");
_factory.Clock.AdvanceSeconds(1);
var history = await client.GetFromJsonAsync <List <TodoHistoryItem> >("/api/todo/history", options : DefaultJsonOptions.Options);
DeepAssert.Equal(new List <TodoHistoryItem> {
new TodoHistoryItem("Item created: First todo", Instant.FromUtc(2020, 2, 3, 4, 5, 0)),
new TodoHistoryItem("Item finished: First todo", Instant.FromUtc(2020, 2, 3, 4, 5, 1)),
new TodoHistoryItem("Item created: Second todo", Instant.FromUtc(2020, 2, 3, 4, 5, 2)),
new TodoHistoryItem("Item restarted: First todo", Instant.FromUtc(2020, 2, 3, 4, 5, 3)),
new TodoHistoryItem("Item finished: Second todo", Instant.FromUtc(2020, 2, 3, 4, 5, 4)),
new TodoHistoryItem("Item deleted: First todo", Instant.FromUtc(2020, 2, 3, 4, 5, 5)),
}, history);
}
public async Task Handle_Async_Published_Create_TodoItem_Rejected_If_TodoItem_With_Given_Id_Exists()
{
CreateTodo command = new CreateTodo(_id, _title, _description, _isDone, _userId);
_todoItemRepository
.ExistsAsync(_id)
.Returns(true);
await Act(command);
await _busPublisher
.Received()
.PublishAsync(Arg.Is <CreateTodoItemRejected>(e => e.Id == command.Id && e.Code == "todo_item_already_exists" && e.Reason == "Todo Item: already exists."), _context);
}
public async Task Handle_Async_Published_Todo_Item_Created_If_Ok()
{
CreateTodo command = new CreateTodo(_id, _title, _description, _isDone, _userId);
_todoItemRepository
.ExistsAsync(_id)
.Returns(false);
await Act(command);
await _busPublisher
.Received()
.PublishAsync(Arg.Is <TodoItemCreated>(e => e.Id == command.Id && e.Title == command.Title && e.Description == command.Description && e.IsDone == command.IsDone && e.UserId == command.UserId), _context);
}
public async Task Toggles_todo_complete()
{
var client = _factory.CreateClient();
EntityId newTodoId;
{
var newTodo = new CreateTodo()
{
Title = "New todo"
};
var postResponse = await client.PostAsJsonAsync("/api/todo", newTodo);
postResponse.EnsureSuccessStatusCode();
newTodoId = await postResponse.Content.ReadFromJsonAsync <EntityId>();
}
{
var response = await client.GetFromJsonAsync <List <TodoItem> >("/api/todo");
var createdTodo = Assert.Single(response);
Assert.False(createdTodo.IsFinished);
}
{
var postResponse = await client.PostAsJsonAsync($"/api/todo/{newTodoId}/finish", "");
postResponse.EnsureSuccessStatusCode();
}
{
var response = await client.GetFromJsonAsync <List <TodoItem> >("/api/todo");
var createdTodo = Assert.Single(response);
Assert.True(createdTodo.IsFinished);
}
{
var postResponse = await client.PostAsJsonAsync($"/api/todo/{newTodoId}/start", "");
postResponse.EnsureSuccessStatusCode();
}
{
var response = await client.GetFromJsonAsync <List <TodoItem> >("/api/todo");
var createdTodo = Assert.Single(response);
Assert.False(createdTodo.IsFinished);
}
}
public async Task <IActionResult> Handle(CreateTodo request, CancellationToken cancellationToken)
{
var todoItem = new TodoItem
{
IsComplete = request.DTO.IsComplete,
Name = request.DTO.Name
};
_context.TodoItems.Add(todoItem);
await _context.SaveChangesAsync(cancellationToken);
return(new ObjectResult(todoItem.ToDTO())
{
StatusCode = StatusCodes.Status201Created
});
}
public async Task ShouldReturnSuccess()
{
var todoRepository = new Mock <ITodoRepository>();
var handler = new CreateTodoHandler(todoRepository.Object);
var createTodo = new CreateTodo
{
Id = Guid.NewGuid(),
Title = "I have todo something important, I just not know what",
Deadline = new DateTime(year: 2020, month: 6, day: 13)
};
var result = await handler.Execute(createTodo);
Assert.True(result.IsSuccess);
}
public async Task WhenAddHasFailedShouldReturnFailure()
{
var todoRepository = new Mock <ITodoRepository>();
todoRepository.Setup(it => it.Add(It.IsAny <Todo>())).Returns(() => Task.FromResult(Result.Failure("Something has gone wrong")));
var handler = new CreateTodoHandler(todoRepository.Object);
var createTodo = new CreateTodo
{
Id = Guid.NewGuid(),
Title = "I have todo something important, I just not know what",
Deadline = new DateTime(year: 2020, month: 6, day: 13)
};
var result = await handler.Execute(createTodo);
Assert.True(result.IsFailure);
}
public async Task ShouldAddANewTodo()
{
var todoRepository = new FakeTodoRepository();
var handler = new CreateTodoHandler(todoRepository);
var createTodo = new CreateTodo
{
Id = Guid.NewGuid(),
Title = "Test",
Deadline = new DateTime(year: 2020, month: 6, day: 13)
};
await handler.Execute(createTodo);
var count = await todoRepository.Count();
Assert.Equal(1, count);
}
public async Task Posts_new_todo()
{
var client = _factory.CreateClient();
var newTodo = new CreateTodo()
{
Title = "New todo"
};
var postResponse = await client.PostAsJsonAsync("/api/todo", newTodo);
postResponse.EnsureSuccessStatusCode();
var newTodoId = await postResponse.Content.ReadFromJsonAsync <EntityId>();
var response = await client.GetFromJsonAsync <List <TodoItem> >("/api/todo");
var createdTodo = Assert.Single(response);
Assert.Equal(newTodoId, createdTodo.Id);
Assert.Equal("New todo", createdTodo.Title);
}
public async static Task Main(string[] args)
{
var context = new ApplicationContext();
var todoRepository = new EFTodoRepository(context);
var handler = new CreateTodoHandler(todoRepository);
Console.WriteLine("Todo title:");
var title = Console.ReadLine();
var createTodo = new CreateTodo
{
Id = Guid.NewGuid(),
Title = title,
Deadline = DateTime.Now.AddDays(1)
};
var result = await handler.Execute(createTodo);
if (result.IsFailure)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(result.Error);
Console.ResetColor();
return;
}
await context.SaveChangesAsync();
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Todo has been added");
Console.ResetColor();
}
public Task <Result> Execute(CreateTodo createTodo)
{
var todo = new Todo(createTodo.Id, createTodo.Title, createTodo.Deadline);
return(_todoRepository.Add(todo));
}
public async Task <ActionResult> Create(CreateTodo item)
{
await _mediator.SendAsync(item);
return(RedirectToAction("Index"));
}
private static async Task CreateTodo(CreateTodo item)
{
var handler = new CreateTodoHandler(_db.Database);
await handler.SendAsync(item);
}
private async Task Act(CreateTodo command) => await _commandHandler.HandleAsync(command, _context);
public async Task <IActionResult> Post(CreateTodo command)
=> await SendAsync(command.BindId(c => c.Id),
resourceId : command.Id, resource : "products");
public async Task Execute(CreateTodo createTodo)
{
var todo = new Todo(createTodo.Id, createTodo.Title, createTodo.Deadline);
await _todoRepository.Add(todo);
}
private async Task OnCreateTodo(CreateTodo todo, CancellationToken ct)
{
var newTodo = await _todoRepo.AddAsync(todo.Title);
await _publisher.PublishAsync(new TodoCreated(newTodo), ct);
}
