public async Task <TodoItemEntity> GetTodoItem(long id)
{
TodoItemEntity ItemList = new TodoItemEntity();
try
{
Log.Information("Inside GetTodoItem Param : " + id);
var items = _sampleAppDbContext.Items
.Where(e => e.Id == id)
.FirstOrDefault();
if (items != null)
{
return(items);
}
return(null);
}
catch (Exception ex)
{
Log.Information("Error in GetTranspotersByContainerNumber : " + ex.Message.ToString());
var errorMessage = string.Format("Error encountered on server. Message:'{0}' when writing an object", ex.Message);
//Log in database
}
return(ItemList);
}
/// <summary>
/// Converts a <see cref="ClientEntity"/> to a <see cref="Client"/> model.
/// </summary>
public static TodoItem ToModel(this TodoItemEntity entity)
{
return(new TodoItem(
entity.Id,
entity.Name,
entity.IsComplete));
}
public OperationDetails UpdateTodoItem(TodoItemDTO todoItem)
{
var entity = new TodoItemEntity
{
DueDate = todoItem.DueDate,
Id = todoItem.Id,
IsCompleted = todoItem.IsCompleted,
Name = todoItem.Name,
Note = todoItem.Note,
OrderNumber = todoItem.OrderNumber,
TodoListEntityId = todoItem.TodoListEntityId
};
bool normalizationRequired = false;
if (todoItem.ChangedFromCompletedToIncompleted)
{
todoItem.OrderNumber = GetToDoItemOrderingNumber(todoItem.TodoListEntityId, -1,
out normalizationRequired);
}
else
{
if (todoItem.IncertToPlace > -1)
{
todoItem.OrderNumber = GetToDoItemOrderingNumber(todoItem.TodoListEntityId, -1,
out normalizationRequired);
}
}
_todoItemRepository.Update(entity);
db.Commit();
if (normalizationRequired)
{
NormalizeToDoItemOrderingNumbers();
}
return(new OperationDetails(true, "TodoItem успешно изменён", ""));
}
public async Task <TodoItemEntity> PostTodoItem(TodoItemEntity todoItemEntity)
{
Log.Information("Inside PostTodoItem:");
await _sampleAppDbContext.Items.AddAsync(todoItemEntity);
await _sampleAppDbContext.SaveChangesAsync();
return(todoItemEntity);
}
public static TodoItem MapToTodoItem(TodoItemEntity source)
{
Guard.AgainstNull(source, nameof(source));
var target = new TodoItem();
MapToTodoItem(source, target);
return(target);
}
public async Task <TodoItemEntity> GetTodoItemsById([Service] TestRepository testRepository,
[Service] ITopicEventSender eventSender, int id)
{
TodoItemEntity gotItemById = await testRepository.GetTodoItem(id);
await eventSender.SendAsync("ReturnedItems", gotItemById);
return(gotItemById);
}
private TodoItemEntity GetInputData()
{
TodoItemEntity sampleItem = new TodoItemEntity();
sampleItem.Id = 1;
sampleItem.Description = "item1";
sampleItem.IsComplete = true;
return(sampleItem);
}
public static void MapToTodoItem(TodoItemEntity source, TodoItem target)
{
Guard.AgainstNull(source, nameof(source));
Guard.AgainstNull(target, nameof(target));
target.Id = source.Id;
target.Name = source.Name;
target.Description = source.Description;
target.Priority = source.Priority;
target.IsComplete = source.IsComplete;
}
public static TodoItem ConverToDto(this TodoItemEntity todoItem)
{
var newValue = new TodoItem();
newValue.Description = todoItem.Description;
newValue.IsCompleted = todoItem.IsCompleted;
newValue.ListId = todoItem.ListId;
newValue.Title = todoItem.Title;
newValue.TodoId = todoItem.TodoId;
return(newValue);
}
public OperationDetails DeleteTodoItem(TodoItemDTO todoItem)
{
TodoItemEntity todoItemEntity = _todoItemRepository.GetTodoItemById(todoItem.Id);
if (todoItemEntity != null)
{
_todoItemRepository.Delete(todoItemEntity);
db.Commit();
return(new OperationDetails(true, "TodoItem успешно удален", ""));
}
return(new OperationDetails(false, "todoItem, который должен быть удален отсутствует", "Id"));
}
public void Update(int id, TodoItem item)
{
var connectionString = RuntimeConfiguration.GetConnectionString("TodoContext");
using var adapter = new DataAccessAdapter(connectionString);
var entity = new TodoItemEntity {
Id = id
};
adapter.FetchEntity(entity);
entity.Title = item.Title;
adapter.SaveEntity(entity);
}
public async Task <TodoItemEntity> DeleteTodoItem([Service] TestRepository testRepository,
[Service] ITopicEventSender eventSender, int id)
{
var newTodoItem = new TodoItemEntity
{
Id = id,
};
var deletedTodoItem = await testRepository.DeleteTodoItem(newTodoItem.Id);
await eventSender.SendAsync("TodoItemDeleted", deletedTodoItem);
return(deletedTodoItem);
}
public async Task <TodoItemEntity> CreateTodoItem([Service] TestRepository testRepository,
[Service] ITopicEventSender eventSender, string description, bool isComplete)
{
var newTodoItem = new TodoItemEntity
{
Description = description,
IsComplete = isComplete
};
var createdTodoItem = await testRepository.PostTodoItem(newTodoItem);
await eventSender.SendAsync("TodoItemCreated", createdTodoItem);
return(createdTodoItem);
}
public void Update(TodoItemEntity item)
{
var entity = _db.Set <TodoItemEntity>().Find(item.Id);
if (entity != null)
{
entity.DueDate = item.DueDate;
entity.IsCompleted = item.IsCompleted;
entity.Name = item.Name;
entity.Note = item.Note;
entity.OrderNumber = item.OrderNumber;
_db.Entry(entity).State = EntityState.Modified;
}
}
public async Task <TodoItemDto> Handle(
CreateTodoItemCommand request,
CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
var title = request.Title;
var status = request.Status;
var entity = new TodoItemEntity(title: title, status: status);
await _dbContext.TodoItems.AddAsync(entity : entity, cancellationToken : cancellationToken);
await _dbContext.SaveChangesAsync(cancellationToken : cancellationToken);
return(_mapper.Map <TodoItemDto>(source: entity));
}
public static void AssertTodoItem(TodoItemEntity expected, TodoItem actual)
{
if (expected == null && actual == null)
{
return;
}
Assert.IsNotNull(expected);
Assert.IsNotNull(actual);
Assert.AreEqual(expected.Id, actual.Id);
Assert.AreEqual(expected.Description, actual.Description);
Assert.AreEqual(expected.IsComplete, actual.IsComplete);
Assert.AreEqual(expected.Name, actual.Name);
Assert.AreEqual(expected.Priority, actual.Priority);
}
public async Task <TodoItemEntity> PutTodoItem(TodoItemEntity todoItemEntity)
{
Log.Information("Inside PutTodoItem:");
var items = _sampleAppDbContext.Items
.Where(e => e.Id == todoItemEntity.Id)
.FirstOrDefault();
if (items != null)
{
items.Description = todoItemEntity.Description;
items.IsComplete = todoItemEntity.IsComplete;
await _sampleAppDbContext.SaveChangesAsync();
return(todoItemEntity);
}
return(todoItemEntity);
}
public async Task <TodoItemEntity> DeleteTodoItem(int id)
{
Log.Information("Inside DeleteTodoItem: " + id);
var items = _sampleAppDbContext.Items
.Where(e => e.Id == id)
.FirstOrDefault();
TodoItemEntity item = new TodoItemEntity();
if (items != null)
{
item = _sampleAppDbContext.Items.Where(x => x.Id == id).First();
_sampleAppDbContext.Items.Remove(item);
await _sampleAppDbContext.SaveChangesAsync();
return(item);
}
return(item);
}
public async Task <IActionResult> PutTodoItem(long id, TodoItemEntity todoItemEntity)
{
if (id != todoItemEntity.Id)
{
return(BadRequest());
}
//await _testRepository.PutTodoItem(id, todoItem);
try
{
await _testRepository.PutTodoItem(todoItemEntity);//_context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
return(NotFound());
}
return(NoContent());
}
public OperationDetails CreateTodoItem(TodoItemDTO todoItem)
{
var todoItemEntity = new TodoItemEntity
{
TodoListEntityId = todoItem.TodoListEntityId,
Name = todoItem.Name,
Note = todoItem.Note,
IsCompleted = false
};
bool normalizationRequired;
todoItemEntity.OrderNumber = GetToDoItemOrderingNumber(todoItemEntity.TodoListEntityId, -1,
out normalizationRequired);
_todoItemRepository.Create(todoItemEntity);
db.Commit();
if (normalizationRequired)
{
NormalizeToDoItemOrderingNumbers();
}
return(new OperationDetails(true, "TodoItem успешно добавлен", ""));
}
public async Task <TodoItem> CreateTodoItem(string title, string description, Guid todoListId)
{
var list = await uow.TodoListRepository.Get(todoListId);
if (list == null)
{
throw new ArgumentException("The todo list does not exist");
}
var newItem = new TodoItemEntity();
newItem.Title = title;
newItem.Description = description;
newItem.ListId = todoListId;
if (await newItem.Save(uow.TodoItemRepository).ConfigureAwait(false))
{
return(newItem.ConverToDto());
}
return(null);
}
public void AddTodo([FromBody] TodoItemEntity todos) => todoRepository.Add(todos);
public async Task <ActionResult <TodoItemEntity> > PostTodoItem(TodoItemEntity todoItemEntity)
{
await _testRepository.PostTodoItem(todoItemEntity);
return(CreatedAtAction(nameof(GetTodoItem), new { id = todoItemEntity.Id }, todoItemEntity));
}
public ActionResult TodoItem()
{
TodoItemEntity todoItems = new TodoItemEntity();
return(View(todoItems));
}
public void Delete(TodoItemEntity item)
{
_todoEntityDbSet.Remove(item);
}
public void Create(TodoItemEntity item)
{
_todoEntityDbSet.Add(item);
}
public void UpdateTodo([FromBody] TodoItemEntity todos) => todoRepository.Update(todos);
