public void MapFrom_Should_ReturnCorrectInstanceOf_BarDto()
{
//Arrange
var sut = new BarCommentDtoMapper();
var barComment = new BarComment
{
Bar = new Bar
{
Id = Guid.NewGuid(),
Name = "testBar",
Info = "testInfo",
ImagePath = "testPath",
Address = "testAddress",
GoogleMapsURL = "GoogleMapsURL",
Phone = "111-333-666"
},
User = new User
{
Id = Guid.NewGuid(),
UserName = "******",
Email = "*****@*****.**"
},
Body = "testBody",
CreatedOn = DateTime.MinValue,
};
//Act
var result = sut.MapFrom(barComment);
//Assert
Assert.IsInstanceOfType(result, typeof(BarCommentDto));
}
public void ReturnCorrectInstance_OfType_BarCommentDto()
{
//Arrange
var sut = new BarCommentDtoMapper();
var bar = new Bar
{
Id = 1,
Name = "TestBar",
Info = "TestInfo",
};
var user = new User
{
Id = 1,
UserName = "******",
Email = "*****@*****.**",
};
var barComment = new BarComment
{
BarId = 1,
UserId = 1,
Text = "TestComment",
Author = user,
CreatedOn = DateTime.MinValue,
};
//Act
var result = sut.MapDto(barComment);
//Assert
Assert.IsInstanceOfType(result, typeof(BarCommentDto));
}
public void Correctly_Map_FromBarComment_ToBarCommentDto()
{
//Arrange
var sut = new BarCommentDtoMapper();
var bar = new Bar
{
Id = 1,
Name = "TestBar",
Info = "TestInfo",
};
var user = new User
{
Id = 1,
UserName = "******",
Email = "*****@*****.**",
};
var barComment = new BarComment
{
BarId = 1,
UserId = 1,
Text = "TestComment",
Author = user,
CreatedOn = DateTime.MinValue,
};
//Act
var result = sut.MapDto(barComment);
//Assert
Assert.AreEqual(result.BarId, barComment.BarId);
Assert.AreEqual(result.UserId, barComment.UserId);
Assert.AreEqual(result.Text, barComment.Text);
Assert.AreEqual(result.CreatedOn, barComment.CreatedOn);
}
public async Task EditComment_Throws_When_NoCommentFound()
{
//Arrange
var options = Utils.GetOptions(nameof(EditComment_Throws_When_NoCommentFound));
var user = new User {
Id = Guid.NewGuid(), UserName = "******"
};
var bar = new Bar {
Id = Guid.NewGuid(), Name = "Manhattan"
};
var barComment = new BarComment {
BarId = bar.Id, UserId = user.Id, Comments = "My favorite"
};
var commentId = Guid.NewGuid();
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Bars.AddAsync(bar);
await arrangeContext.Users.AddAsync(user);
await arrangeContext.BarComments.AddAsync(barComment);
await arrangeContext.SaveChangesAsync();
}
//Act, Assert
using (var assertContext = new CMContext(options))
{
var sut = new BarCommentsServices(assertContext);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.EditComment(commentId, "Changes made"));
}
}
public async Task AddBarCommentAsync(int id, string createComment, int userId)
{
if (await dbContext.BarComment.AnyAsync(p => (p.UserId == userId && p.BarId == id)))
{
var givenComment = await dbContext.BarComment.FirstOrDefaultAsync(p => (p.UserId == userId && p.BarId == id));
givenComment.Comment = createComment;
givenComment.CreatedOn = DateTime.Now;
await dbContext.SaveChangesAsync();
}
else
{
var user = await FindUserByIdAsync(userId);
var bar = await barService.FindBarByIdAsync(id);
var barComment = new BarComment()
{
User = user,
Bar = bar,
UserUserName = user.UserName,
BarName = bar.Name,
Comment = createComment,
CreatedOn = DateTime.Now
};
await dbContext.BarComment.AddAsync(barComment);
await dbContext.SaveChangesAsync();
}
}
public async Task <BarCommentDto> CreateCommentAsync(BarCommentDto tempBarComment)
{
if (tempBarComment == null)
{
return(null);
}
if (tempBarComment.Text == null || tempBarComment.UserId < 1 || tempBarComment.BarId < 1)
{
return(null);
}
var newBarComment = new BarComment
{
Id = tempBarComment.Id,
Text = tempBarComment.Text,
BarId = tempBarComment.BarId,
UserId = tempBarComment.UserId,
Author = this.context.Users
.FirstOrDefault(a => a.UserName == tempBarComment.Author),
CreatedOn = this.dateTimeProvider.GetDateTime(),
};
await this.context.AddAsync(newBarComment);
await this.context.SaveChangesAsync();
var barCommentDto = this.dtoMapper.MapDto(newBarComment);
return(barCommentDto);
}
public async Task <BarCommentDto> CreateAsync(BarCommentDto tempBarComment)
{
if (tempBarComment == null)
{
throw new BusinessLogicException(ExceptionMessages.BarCommentNull);
}
if (String.IsNullOrEmpty(tempBarComment.Body))
{
throw new BusinessLogicException(ExceptionMessages.GeneralOopsMessage);
}
var barComment = new BarComment
{
Id = tempBarComment.Id,
BarId = tempBarComment.BarId,
UserId = tempBarComment.UserId,
Body = tempBarComment.Body,
CreatedOn = tempBarComment.CreatedOn,
ModifiedOn = tempBarComment.ModifiedOn,
DeletedOn = tempBarComment.DeletedOn,
IsDeleted = tempBarComment.IsDeleted
};
await this.context.BarComments.AddAsync(barComment);
await this.context.SaveChangesAsync();
var barCommentDto = this.dtoMapper.MapFrom(barComment);
return(barCommentDto);
}
public async Task CorrectlyCreateBarComment()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(CorrectlyCreateBarComment));
var mapperMock = new Mock <IDtoMapper <BarComment, BarCommentDto> >();
var id = Guid.NewGuid();
var barId = Guid.NewGuid();
var userId = Guid.NewGuid();
var createdOn = DateTime.UtcNow;
var entityDto = new BarCommentDto
{
Id = id,
BarId = barId,
UserId = userId,
UserName = "******",
Body = "testbody",
CreatedOn = createdOn
};
var entity = new BarComment
{
Id = id,
BarId = barId,
UserId = userId,
Body = "testbody",
CreatedOn = createdOn
};
mapperMock.Setup(x => x.MapFrom(It.IsAny <BarComment>())).Returns(entityDto);
using (var assertContext = new CWContext(options))
{
//Assert
var sut = new BarCommentService(assertContext, mapperMock.Object);
var result = await sut.CreateAsync(entityDto);
Assert.IsInstanceOfType(result, typeof(BarCommentDto));
Assert.AreEqual(id, result.Id);
Assert.AreEqual(barId, result.BarId);
Assert.AreEqual(userId, result.UserId);
Assert.AreEqual("testbody", result.Body);
Assert.AreEqual("testuser", result.UserName);
Assert.AreEqual(entityDto.Id, result.Id);
Assert.AreEqual(entityDto.BarId, result.BarId);
Assert.AreEqual(entityDto.UserId, result.UserId);
Assert.AreEqual(entityDto.Body, result.Body);
Assert.AreEqual(entityDto.UserName, result.UserName);
}
}
public async Task ReturnCorrectTypeOfEntity()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ReturnCorrectTypeOfEntity));
var mapperMock = new Mock <IDtoMapper <BarComment, BarCommentDto> >();
var id = Guid.NewGuid();
var barId = Guid.NewGuid();
var userId = Guid.NewGuid();
var createdOn = DateTime.UtcNow;
var entityDto = new BarCommentDto
{
Id = id,
BarId = barId,
UserId = userId,
UserName = "******",
Body = "testbody",
CreatedOn = createdOn
};
var entity = new BarComment
{
Id = id,
BarId = barId,
UserId = userId,
Body = "testbody",
CreatedOn = createdOn
};
mapperMock.Setup(x => x.MapFrom(It.IsAny <BarComment>())).Returns(entityDto);
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.BarComments.AddAsync(entity);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new BarCommentService(assertContext, mapperMock.Object);
var result = await sut.EditAsync(id, "newbody");
Assert.IsInstanceOfType(result, typeof(BarCommentDto));
}
}
public async Task ReturnCorrectBarCommentWhen_ParamsAreValid()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ReturnCorrectBarCommentWhen_ParamsAreValid));
var mapperMock = new Mock <IDtoMapper <BarComment, BarCommentDto> >();
var id = Guid.NewGuid();
var barId = Guid.NewGuid();
var createdOn = DateTime.UtcNow;
var entity = new BarComment
{
Id = id,
BarId = barId,
UserId = Guid.NewGuid(),
Body = "testbody",
CreatedOn = createdOn
};
//var entityDto = new BarCommentDto
//{
// Id = id,
// BarId = barId,
// UserId = Guid.NewGuid(),
// Body = "testbody",
// CreatedOn = createdOn
//};
//mapperMock.Setup(x => x.MapFrom(It.IsAny<BarComment>())).Returns(entityDto);
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.BarComments.AddAsync(entity);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new BarCommentService(assertContext, mapperMock.Object);
//var result = await sut.GetBarCommentAsync(barId);
//Assert.IsInstanceOfType(result, typeof(BarComment));
//Assert.AreEqual("testbody", result.Body);
}
}
public async Task GetAllCommentsForBar_Returns_Correct_WhenParam_IsValid()
{
//Arrange
var options = Utils.GetOptions(nameof(GetAllCommentsForBar_Returns_Correct_WhenParam_IsValid));
var user = new User {
Id = Guid.NewGuid(), UserName = "******"
};
var user2 = new User {
Id = Guid.NewGuid(), UserName = "******"
};
var bar = new Bar {
Id = Guid.NewGuid(), Name = "Manhattan"
};
var barComment = new BarComment {
BarId = bar.Id, UserId = user.Id
};
var barComment2 = new BarComment {
BarId = bar.Id, UserId = user2.Id
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Bars.AddAsync(bar);
await arrangeContext.Users.AddRangeAsync(user, user2);
await arrangeContext.BarComments.AddRangeAsync(barComment, barComment2);
await arrangeContext.SaveChangesAsync();
}
//Act, Assert
using (var assertContext = new CMContext(options))
{
var sut = new BarCommentsServices(assertContext);
var result = await sut.GetAllCommentsForBar(bar.Id, "Manhattan");
Assert.AreEqual(2, result.Count());
Assert.AreEqual(result.ToList()[0].UserId, user.Id);
Assert.AreEqual(result.ToList()[1].UserId, user2.Id);
Assert.IsInstanceOfType(result, typeof(ICollection <BarCommentDTO>));
}
}
public async Task GetAllCommentsOfUser_ShouldReturn_Correct()
{
//Arrange
var options = Utils.GetOptions(nameof(GetAllCommentsOfUser_ShouldReturn_Correct));
var user = new User {
Id = Guid.NewGuid(), UserName = "******"
};
var bar = new Bar {
Id = Guid.NewGuid(), Name = "Manhattan"
};
var bar2 = new Bar {
Id = Guid.NewGuid(), Name = "Cosmos"
};
var comment = new BarComment {
BarId = bar.Id, UserId = user.Id
};
var comment2 = new BarComment {
BarId = bar2.Id, UserId = user.Id, IsDeleted = true
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Bars.AddRangeAsync(bar, bar2);
await arrangeContext.Users.AddAsync(user);
await arrangeContext.BarComments.AddRangeAsync(comment, comment2);
await arrangeContext.SaveChangesAsync();
}
//Act, Assert
using (var assertContext = new CMContext(options))
{
//TODO: Replace USername with id
var sut = new BarCommentsServices(assertContext);
var result = await sut.GetAllCommentsOfUser(user.Id);
Assert.AreEqual(1, result.Count);
Assert.IsInstanceOfType(result, typeof(ICollection <BarCommentDTO>));
}
}
public async Task GetAllCommentsForBar_Returns_OnlyExistingEntities()
{
//Arrange
var options = Utils.GetOptions(nameof(GetAllCommentsForBar_Returns_OnlyExistingEntities));
var user = new User {
Id = Guid.NewGuid(), UserName = "******"
};
var user2 = new User {
Id = Guid.NewGuid(), UserName = "******"
};
var bar = new Bar {
Id = Guid.NewGuid(), Name = "Manhattan"
};
var barComment = new BarComment {
BarId = bar.Id, UserId = user.Id
};
var barComment2 = new BarComment {
BarId = bar.Id, UserId = user2.Id, IsDeleted = true
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Bars.AddAsync(bar);
await arrangeContext.Users.AddRangeAsync(user, user2);
await arrangeContext.BarComments.AddRangeAsync(barComment, barComment2);
await arrangeContext.SaveChangesAsync();
}
//Act, Assert
using (var assertContext = new CMContext(options))
{
var sut = new BarCommentsServices(assertContext);
var result = await sut.GetAllCommentsForBar(bar.Id, "Manhattan");
Assert.AreEqual(1, result.Count());
}
}
public static BarCommentDTO GetDTO(this BarComment item)
{
if (item == null)
{
throw new ArgumentNullException();
}
return(new BarCommentDTO
{
BarId = item.BarId,
UserId = item.UserId,
User = item.User,
IsDeleted = item.IsDeleted,
Comments = item.Comments,
CreatedOn = item.CreatedOn,
DeletedOn = item.DeletedOn,
ModifiedOn = item.ModifiedOn,
});
}
public async Task CorrectlyUpdateEntity()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(CorrectlyUpdateEntity));
var mapperMock = new Mock <IDtoMapper <BarComment, BarCommentDto> >();
var id = Guid.NewGuid();
var barId = Guid.NewGuid();
var userId = Guid.NewGuid();
var createdOn = DateTime.UtcNow;
var entity = new BarComment
{
Id = id,
BarId = barId,
UserId = userId,
Body = "testbody",
CreatedOn = createdOn
};
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.BarComments.AddAsync(entity);
await arrangeContext.SaveChangesAsync();
}
mapperMock.Setup(x => x.MapFrom(It.IsAny <BarComment>())).Returns(It.IsAny <BarCommentDto>);
using (var assertContext = new CWContext(options))
{
var sut = new BarCommentService(assertContext, mapperMock.Object);
var result = await sut.EditAsync(id, "newbody");
var modifiedComment = await assertContext.BarComments.FirstAsync();
Assert.AreEqual("newbody", modifiedComment.Body);
}
}
public async Task ThrowWhen_NoCommentFound()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ThrowWhen_NoCommentFound));
var mapperMock = new Mock <IDtoMapper <BarComment, BarCommentDto> >();
var id = Guid.NewGuid();
var barId = Guid.NewGuid();
var userId = Guid.NewGuid();
var fakeId = Guid.NewGuid();
var createdOn = DateTime.UtcNow;
var entity = new BarComment
{
Id = id,
BarId = barId,
UserId = userId,
Body = "testbody",
CreatedOn = createdOn
};
mapperMock.Setup(x => x.MapFrom(It.IsAny <BarComment>())).Returns(It.IsAny <BarCommentDto>);
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.BarComments.AddAsync(entity);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new BarCommentService(assertContext, mapperMock.Object);
await Assert.ThrowsExceptionAsync <BusinessLogicException>(() => sut.EditAsync(fakeId, "newbody"));
}
}
public async Task DeleteComment_ShouldDelete_Correct()
{
//Arrange
var options = Utils.GetOptions(nameof(DeleteComment_ShouldDelete_Correct));
var user = new User {
Id = Guid.NewGuid(), UserName = "******"
};
var bar = new Bar {
Id = Guid.NewGuid(), Name = "Manhattan"
};
var barComment = new BarComment {
BarId = bar.Id, UserId = user.Id
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Bars.AddAsync(bar);
await arrangeContext.Users.AddAsync(user);
await arrangeContext.BarComments.AddAsync(barComment);
await arrangeContext.SaveChangesAsync();
}
//Act, Assert
using (var assertContext = new CMContext(options))
{
var sut = new BarCommentsServices(assertContext);
var result = await sut.DeleteComment(barComment.Id);
Assert.AreEqual(true, result.IsDeleted);
Assert.AreEqual(user.Id, result.UserId);
Assert.AreEqual(bar.Id, result.BarId);
Assert.IsInstanceOfType(result, typeof(BarCommentDTO));
}
}
public void MapFrom_Should_CorrectlyMapFrom_Bar_To_BarCommentDto()
{
//Arrange
var sut = new BarCommentDtoMapper();
var barComment = new BarComment
{
Bar = new Bar
{
Id = Guid.NewGuid(),
Name = "testBar",
Info = "testInfo",
ImagePath = "testPath",
Address = "testAddress",
GoogleMapsURL = "GoogleMapsURL",
Phone = "111-333-666"
},
User = new User
{
Id = Guid.NewGuid(),
UserName = "******",
Email = "*****@*****.**"
},
Body = "testBody",
CreatedOn = DateTime.MinValue,
};
//Act
var result = sut.MapFrom(barComment);
//Assert
Assert.AreEqual(result.BarId, barComment.BarId);
Assert.AreEqual(result.UserId, barComment.UserId);
//Assert.AreEqual(result.UserName, barComment.User.Email.Split('@')[0]);
Assert.AreEqual(result.Body, barComment.Body);
Assert.AreEqual(result.CreatedOn, barComment.CreatedOn);
}
public async Task EditComment_Updates_Correctly()
{
//Arrange
var options = Utils.GetOptions(nameof(EditComment_Updates_Correctly));
var user = new User {
Id = Guid.NewGuid(), UserName = "******"
};
var bar = new Bar {
Id = Guid.NewGuid(), Name = "Manhattan"
};
var barComment = new BarComment {
BarId = bar.Id, UserId = user.Id, Comments = "Good one"
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Bars.AddAsync(bar);
await arrangeContext.Users.AddAsync(user);
await arrangeContext.BarComments.AddAsync(barComment);
await arrangeContext.SaveChangesAsync();
}
//Act, Assert
using (var assertContext = new CMContext(options))
{
var sut = new BarCommentsServices(assertContext);
var result = await sut.EditComment(barComment.Id, "Changes made");
Assert.AreEqual("Changes made", result.Comments);
Assert.IsInstanceOfType(result, typeof(BarCommentDTO));
}
}
public async Task CorrectlyDeleteBarComment()
{
// Arrange
var options = TestUtilities.GetOptions(nameof(CorrectlyDeleteBarComment));
var mapperMock = new Mock <IDtoMapper <BarComment, BarCommentDto> >();
var id = Guid.NewGuid();
var barId = Guid.NewGuid();
var userId = Guid.NewGuid();
var createdOn = DateTime.UtcNow;
var bar = new Bar
{
Id = barId,
Name = "testname"
};
var user = new User
{
Id = userId,
UserName = "******",
};
var entity = new BarComment
{
Id = id,
BarId = barId,
Bar = bar,
UserId = Guid.NewGuid(),
User = user,
Body = "testbody",
CreatedOn = createdOn
};
bar.Comments.Add(entity);
user.BarComments.Add(entity);
using (var actContext = new CWContext(options))
{
//Act
await actContext.Bars.AddAsync(bar);
await actContext.Users.AddAsync(user);
await actContext.BarComments.AddAsync(entity);
await actContext.SaveChangesAsync();
var service = new BarCommentService(actContext, mapperMock.Object);
var result = await service.DeleteAsync(id, barId);
await actContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Assert
var result = await assertContext.BarComments.FirstAsync();
Assert.AreEqual(true, result.IsDeleted);
}
}
public async Task Return_CorrectModel_When_ParamsAreValid()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(Return_CorrectModel_When_ParamsAreValid));
var mockDateTimeProvider = new Mock <IDateTimeProvider>();
var mockBarCommentDtoMapper = new Mock <IDtoMapper <BarComment, BarCommentDto> >();
var user = new User {
Id = 1
};
var bar = new Bar {
Id = 1
};
var comment1 = new BarComment
{
Id = 1,
UserId = 1,
BarId = 1,
Text = "TestComment1",
};
var comment2 = new BarComment
{
Id = 2,
UserId = 1,
BarId = 1,
Text = "TestComment2",
};
var list = new List <BarCommentDto>
{
new BarCommentDto
{
Id = 1,
UserId = 1,
BarId = 1,
Text = "TestComment1",
},
new BarCommentDto
{
Id = 2,
UserId = 1,
BarId = 1,
Text = "TestComment2",
}
};
mockBarCommentDtoMapper.Setup(x => x.MapDto(It.IsAny <ICollection <BarComment> >())).Returns(list);
using (var arrangeContext = new CocktailMagicianContext(options))
{
await arrangeContext.Bars.AddAsync(bar);
await arrangeContext.Users.AddAsync(user);
await arrangeContext.BarComments.AddAsync(comment1);
await arrangeContext.BarComments.AddAsync(comment2);
await arrangeContext.SaveChangesAsync();
}
//Act and Assert
using (var assertContext = new CocktailMagicianContext(options))
{
var sut = new BarCommentsService(assertContext, mockBarCommentDtoMapper.Object, mockDateTimeProvider.Object);
var result = await sut.GetBarCommentsAsync(1);
Assert.IsInstanceOfType(result, typeof(ICollection <BarCommentDto>));
Assert.AreEqual(1, result.First().Id);
Assert.AreEqual(1, result.First().UserId);
Assert.AreEqual(1, result.First().BarId);
Assert.AreEqual("TestComment1", result.First().Text);
Assert.AreEqual(2, result.Last().Id);
Assert.AreEqual(1, result.Last().UserId);
Assert.AreEqual(1, result.Last().BarId);
Assert.AreEqual("TestComment2", result.Last().Text);
}
}
public async Task ReturnInstanceOfCollectionBarCommentDtos()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ReturnInstanceOfCollectionBarCommentDtos));
var mapperMock = new Mock <IDtoMapper <BarComment, BarCommentDto> >();
var id = Guid.NewGuid();
var twoId = Guid.NewGuid();
var barId = Guid.NewGuid();
var entity = new BarComment
{
Id = id,
BarId = barId,
UserId = Guid.NewGuid(),
Body = "testbody",
};
var entityTwo = new BarComment
{
Id = twoId,
BarId = barId,
UserId = Guid.NewGuid(),
Body = "testbodytwo",
};
var list = new List <BarCommentDto>()
{
new BarCommentDto {
Id = id, BarId = barId, Body = "testbody"
},
new BarCommentDto {
Id = twoId, BarId = barId, Body = "testbodytwo"
},
};
mapperMock.Setup(x => x.MapFrom(It.IsAny <ICollection <BarComment> >())).Returns(list);
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.BarComments.AddAsync(entity);
await arrangeContext.BarComments.AddAsync(entityTwo);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new BarCommentService(assertContext, mapperMock.Object);
var result = await sut.GetBarCommentsAsync(barId);
Assert.IsInstanceOfType(result, typeof(ICollection <BarCommentDto>));
Assert.AreEqual(2, result.Count());
Assert.AreEqual(entity.Body, result.First().Body);
Assert.AreEqual(entity.Id, result.First().Id);
Assert.AreEqual(entityTwo.Body, result.Last().Body);
Assert.AreEqual(entityTwo.Id, result.Last().Id);
}
}
