public async Task <IActionResult> Put(Update.Request request)
{
var result =
await this.mediator.Send(request);
return(Ok());
}
public async Task Should_Update_Meal()
{
_fixture.StartScope();
// Arrange-TestAccount
var testAccount = (TestAccountProvider)_fixture.GetService <ICurrentAccountProvider>();
{ // Arrange-Account
var request = new Api.Features.Account.Create.Request
{
Email = _fixture.GetEmail(),
Password = Guid.NewGuid().ToString()
};
await _fixture.SendAsync(request);
testAccount.Id =
(await _fixture.ExecuteDbContextAsync(db => db.Accounts.SingleOrDefaultAsync(x => x.Email == request.Email))).Id;
}
Guid id;
{
// Arrange-Meal-To-Update
var request = new Create.Request
{
Date = DateTime.UtcNow.Date,
Time = "11:11",
Text = "string",
Calories = 3
};
var response = await _fixture.SendAsync(request);
id = response.Id;
}
{
// Arrange
var request = new Update.Request
{
Id = id,
Date = DateTime.UtcNow.Date.AddDays(1),
Time = "11:15",
Text = "Another String",
Calories = 22
};
// Act
await _fixture.SendAsync(request);
var meal =
await _fixture.ExecuteDbContextAsync(db => db.Meals.SingleOrDefaultAsync(x => x.Id == id));
// Assert
Assert.Equal(request.Date.ToShortDateString(), meal.Date.ToShortDateString());
Assert.Equal(request.Time, meal.Time.ToShortTimeString());
Assert.Equal(request.Text, meal.Text);
Assert.Equal(request.Calories, meal.Calories);
Assert.False(meal.CalorieStatus);
Assert.Equal(testAccount.Id, meal.AccountId);
}
}
public async Task Throws_Update_Exception_If_Sender_Is_Not_Meal_Owner()
{
_fixture.StartScope();
// Arrange-TestAccount(RegularUser)
var testAccount = (TestAccountProvider)_fixture.GetService <ICurrentAccountProvider>();
testAccount.Role = Role.RegularUser;
{ // Arrange-Account
var request = new Api.Features.Account.Create.Request
{
Email = _fixture.GetEmail(),
Password = Guid.NewGuid().ToString()
};
await _fixture.SendAsync(request);
testAccount.Id =
(await _fixture.ExecuteDbContextAsync(db => db.Accounts.SingleOrDefaultAsync(x => x.Email == request.Email))).Id;
}
// This is created by another Account
var createRequest = new Create.Request
{
Date = DateTime.UtcNow.Date,
Time = "11:11",
Text = "string",
Calories = 3
};
var createResponse = await _fixture.SendAsync(createRequest);
{ // Arrange-Account(Change the Account)
var request = new Api.Features.Account.Create.Request
{
Email = _fixture.GetEmail(),
Password = Guid.NewGuid().ToString()
};
await _fixture.SendAsync(request);
testAccount.Id =
(await _fixture.ExecuteDbContextAsync(db => db.Accounts.SingleOrDefaultAsync(x => x.Email == request.Email))).Id;
}
{
// Arrange
var request = new Update.Request
{
Id = createResponse.Id,
Date = DateTime.UtcNow.Date.AddDays(1),
Time = "11:15",
Text = "Another String",
Calories = 22
};
// Act & Assert
await Assert.ThrowsAsync <RestException>(() => _fixture.SendAsync(request));
}
}
public async Task Throws_Update_Exception_For_Invalid_Identifier()
{
_fixture.StartScope();
// Arrange-TestAccount
var testAccount = (TestAccountProvider)_fixture.GetService <ICurrentAccountProvider>();
{ // Arrange-Account
var request = new Api.Features.Account.Create.Request
{
Email = _fixture.GetEmail(),
Password = Guid.NewGuid().ToString()
};
await _fixture.SendAsync(request);
testAccount.Id =
(await _fixture.ExecuteDbContextAsync(db => db.Accounts.SingleOrDefaultAsync(x => x.Email == request.Email))).Id;
}
{
// Arrange-Meal-To-Update
var request = new Create.Request
{
Date = DateTime.UtcNow.Date,
Time = "11:11",
Text = "string",
Calories = 3
};
await _fixture.SendAsync(request);
}
{
// Arrange
var request = new Update.Request
{
Id = Guid.NewGuid(),
Date = DateTime.UtcNow.Date.AddDays(1),
Time = "11:15",
Text = "Another String",
Calories = 22
};
// Act & Assert
await Assert.ThrowsAsync <RestException>(() => _fixture.SendAsync(request));
}
}
public async Task <Update.Response> Update(Update.Request request, CancellationToken cancellationToken)
{
var userId = await _identityService.GetCurrentUserId(cancellationToken);
if (string.IsNullOrEmpty(userId))
{
throw new NoUserFoundException($"Пользователь не найден");
}
var advertisement = await _repository.FindById(request.Id, cancellationToken);
if (advertisement == null)
{
throw new AdNotFoundException(request.Id);
}
if (advertisement.Status == Domain.Advertisement.Statuses.Closed)
{
throw new AdNotFoundException(request.Id);
}
var isAdmin = await _identityService.IsInRole(userId, RoleConstants.AdminRole, cancellationToken);
if (!isAdmin && advertisement.OwnerId != userId)
{
throw new NoRightsException("Нет прав для выполнения операции.");
}
advertisement.Title = request.Title;
advertisement.Location = request.Location;
advertisement.GeoLat = request.GeoLat;
advertisement.GeoLon = request.GeoLon;
advertisement.Description = request.Description;
advertisement.Price = request.Price;
advertisement.Cover = request.Cover;
advertisement.UpdatedDate = DateTime.UtcNow;
advertisement.CategoryId = request.CategoryId;
await _repository.Save(advertisement, cancellationToken);
return(new Update.Response
{
Id = request.Id
});
}
public async Task Update(Update.Request request, CancellationToken cancellationToken)
{
var currentUserId = await _identity.GetCurrentUserId(cancellationToken);
var domainUser = await _repository.FindById(currentUserId, cancellationToken);
if (domainUser == null)
{
throw new NoUserFoundException("Пользователя не существует");
}
domainUser.Name = request.Name;
domainUser.LastName = request.LastName;
domainUser.UpdatedDate = DateTime.UtcNow;
domainUser.Phone = request.Phone;
await _repository.Save(domainUser, cancellationToken);
}
public async Task <IActionResult> Patch(Update.Request request)
{
var token = new CancellationToken();
var cube = await session
.Query <Account>()
.Where(p => p.Id == request.Id)
.Where(p => p.Deleted != true)
.FirstOrDefaultAsync()
.ConfigureAwait(false);
if (cube == null)
{
return(NotFound());
}
session.Events.Append(request.Id, new AccountUpdated(request.CorrelationId, request.JsonPatchDocument));
await session.SaveChangesAsync(token).ConfigureAwait(false);
return(Ok());
}
public async Task Update_Response_Success()
{
var request = new Update.Request
{
Id = 1,
Title = "UpdTitle",
Description = "UpdDesc",
Price = 12345,
Cover = "TestCover",
Status = Update.Statuses.Closed,
UpdateDate = DateTime.UtcNow
};
setupMockForUpdate();
// Act
var response = await advertisementService.Update(request, new CancellationToken());
// Assert
_identityServiceMock.Verify();
Assert.NotNull(response);
Assert.NotEqual(default, response.Id);
public async Task Should_Update_Account()
{
_fixture.StartScope();
// Arrange-TestAccount
var testAccount = (TestAccountProvider)_fixture.GetService <ICurrentAccountProvider>();
{ // Arrange-Account
var request = new Create.Request
{
Email = _fixture.GetEmail(),
Password = Guid.NewGuid().ToString()
};
await _fixture.SendAsync(request);
testAccount.Id =
(await _fixture.ExecuteDbContextAsync(db => db.Accounts.SingleOrDefaultAsync(x => x.Email == request.Email))).Id;
}
{
// Arrange
var request = new Update.Request
{
Password = Guid.NewGuid().ToString()
};
var passwordHasher = _fixture.GetService <IPasswordHasher>();
// Act
await _fixture.SendAsync(request);
var account =
await _fixture.ExecuteDbContextAsync(db => db.Accounts.SingleOrDefaultAsync(x => x.Id == testAccount.Id));
// Assert
Assert.NotNull(account);
Assert.True(passwordHasher.VerifyHashedPassword(request.Password, account.PasswordHash));
}
}
public async Task Update(Update.Request request, CancellationToken cancellationToken)
{
var domainUser = await _repository.FindById(request.Id, cancellationToken);
if (domainUser == null)
{
throw new UserNotFoundException($"Пользователь с идентификатором {request.Id} не найден");
}
var currentUserId = await _identityService.GetCurrentUserId(cancellationToken);
if (domainUser.Id != currentUserId)
{
throw new NoRightsException("Нет прав");
}
domainUser.FirstName = request.FirstName;
domainUser.LastName = request.LastName;
domainUser.MiddleName = request.MiddleName;
domainUser.UpdatedAt = DateTime.UtcNow;
await _repository.Save(domainUser, cancellationToken);
}
public async Task <IActionResult> UpdateBook(int id, [FromBody] Update.Request request)
{
var response = await mediator.Send(new Update.Command(request));
return(Ok(response));
}
public async Task <Update.Response> Update([FromBody] Update.Request request) => await Handle(request);
