public async Task <User> AddColidEntrySubscriptionAsync(Guid userId, ColidEntrySubscriptionDto colidEntrySubscriptionDto)
{
Guard.IsNotNull(userId, colidEntrySubscriptionDto);
var user = await GetOneAsync(u => u.Id.Equals(userId), nameof(User.ColidEntrySubscriptions));
var colidEntrySubscription = _mapper.Map <ColidEntrySubscription>(colidEntrySubscriptionDto);
colidEntrySubscription.User = user;
user.ColidEntrySubscriptions ??= new Collection <ColidEntrySubscription>();
// Check if the user is already subscribed to this resource
var existingSubscription = user.ColidEntrySubscriptions
.Where(ces => colidEntrySubscription.ColidPidUri.AbsoluteUri == ces.ColidPidUri.AbsoluteUri)
.FirstOrDefault();
if (existingSubscription.IsNotEmpty())
{
throw new EntityAlreadyExistsException("The user is already subscribed to the COLID entry.", existingSubscription);
}
user.ColidEntrySubscriptions.Add(colidEntrySubscription);
Update(user);
await SaveAsync();
return(user);
}
public void Delete(ColidEntrySubscriptionDto colidEntrySubscriptionDto)
{
Guard.IsNotNull(colidEntrySubscriptionDto);
Guard.IsValidUri(colidEntrySubscriptionDto.ColidPidUri);
_ceRepo.Delete(colidEntrySubscriptionDto);
}
public void Delete_Should_DoNothing_IfNoEntitesFound()
{
var subscriptionToDelete = new ColidEntrySubscriptionDto()
{
ColidPidUri = new Uri("http://www.iliketo.meh")
};
_repo.Delete(subscriptionToDelete);
}
public void Delete_Should_InvokeColidEntrySubscriptionRepositoryDelete_Once()
{
var dto = new ColidEntrySubscriptionDto()
{
ColidPidUri = new Uri("http://www.this.com/is_a_special_meh!")
};
_subscriptionService.Delete(dto);
_mockSubscriptionRepository.Verify(x => x.Delete(dto), Times.Once);
}
public async Task <User> RemoveColidEntrySubscriptionAsync(Guid userId, ColidEntrySubscriptionDto colidEntrySubscriptionDto)
{
Guard.IsNotNull(userId, colidEntrySubscriptionDto);
var colidEntrySubscription = _colidEntrySubscriptionService.GetOne(userId, colidEntrySubscriptionDto);
_colidEntrySubscriptionService.Delete(colidEntrySubscription);
var entity = await _userRepo.GetOneAsync(userId);
return(entity);
}
public void Delete(ColidEntrySubscriptionDto dto)
{
Guard.IsNotNull(dto);
Guard.IsValidUri(dto.ColidPidUri);
var entities = Context.ColidEntrySubscriptions
.AsEnumerable() // This is necessary due to client evaluation, see https://docs.microsoft.com/de-de/ef/core/querying/client-eval for more
.Where(ce => ce.ColidPidUri.AbsoluteUri == dto.ColidPidUri.AbsoluteUri)
.ToList();
if (entities.Any())
{
base.DeleteRange(entities);
}
}
public async Task <User> AddColidEntrySubscriptionAsync(Guid userId, ColidEntrySubscriptionDto colidEntrySubscriptionDto)
{
Guard.IsNotNull(userId, colidEntrySubscriptionDto);
var entity = await _userRepo.GetOneAsync(userId);
var colidEntrySubscription = _mapper.Map <ColidEntrySubscription>(colidEntrySubscriptionDto);
colidEntrySubscription.User = entity;
entity.ColidEntrySubscriptions ??= new Collection <ColidEntrySubscription>();
CheckIfUserIsAlreadySubscribedToColidPidUri(entity, colidEntrySubscription);
entity.ColidEntrySubscriptions.Add(colidEntrySubscription);
return(_userRepo.Update(entity));
}
public void Delete(ColidEntrySubscriptionDto colidEntrySubscriptionDto)
{
Guard.IsNotNull(colidEntrySubscriptionDto);
Guard.IsValidUri(colidEntrySubscriptionDto.ColidPidUri);
var subscriptions = GetAll()
.AsEnumerable()
.Where(ce => ce.ColidPidUri.AbsoluteUri == colidEntrySubscriptionDto.ColidPidUri.AbsoluteUri)
.ToList();
if (subscriptions.Any())
{
DeleteRange(subscriptions);
Save();
}
}
public async Task <User> RemoveColidEntrySubscriptionAsync(Guid userId, ColidEntrySubscriptionDto colidEntrySubscriptionDto)
{
Guard.IsNotNull(userId, colidEntrySubscriptionDto);
var colidEntrySubscription = _colidEntrySubscriptionService.GetOne(userId, colidEntrySubscriptionDto);
if (colidEntrySubscription.IsEmpty())
{
throw new EntityNotFoundException($"The given subscription on PidUri {colidEntrySubscriptionDto.ColidPidUri} for the user {userId} does not exist!");
}
_colidEntrySubscriptionService.Delete(colidEntrySubscription);
await _colidEntrySubscriptionService.SaveAsync();
var user = await GetOneAsync(u => u.Id.Equals(userId), nameof(User.ColidEntrySubscriptions));
return(user);
}
public ColidEntrySubscription GetOne(Guid userId, ColidEntrySubscriptionDto dto)
{
Guard.IsNotNull(dto);
Guard.IsValidUri(dto.ColidPidUri);
var colidPidUri = dto.ColidPidUri.AbsoluteUri;
var colidEntriesPerUri = GetAll(null, nameof(ColidEntrySubscription.User))
.AsEnumerable()
.Where(ce => ce.ColidPidUri.AbsoluteUri == colidPidUri)
.ToList();
var colidEntry = colidEntriesPerUri.FirstOrDefault(ce => ce.User.Id.Equals(userId));
if (colidEntry.IsEmpty())
{
throw new EntityNotFoundException($"Unable to find a subscription with the Uri {colidPidUri} for user {userId}", colidPidUri);
}
return(colidEntry);
}
public async Task <int> CreateDeleteMessagesAndRemoveColidEntrySubscriptions(ColidEntryDto colidEntryDto)
{
if (!_colidEntrySubscriptionService.TryGetAllUsers(colidEntryDto.ColidPidUri, out var colidEntrySubscribedUsers))
{
// no one subscribed to the given colid pidUri
return(0);
}
var amountUsersNotified = await CreateMessagesForColidEntrySubscriptions(colidEntryDto, MessageType.ColidEntrySubscriptionDelete, colidEntrySubscribedUsers);
// remove subscription from all users
var subscriptionDto = new ColidEntrySubscriptionDto()
{
ColidPidUri = colidEntryDto.ColidPidUri
};
_colidEntrySubscriptionService.Delete(subscriptionDto);
return(amountUsersNotified);
}
public void Delete_Should_CallDeleteRange_IfEntitiesFound()
{
var user = TestData.GenerateRandomUser(); // will be created with add of subscription next line
var subscription = TestData.GenerateRandomColidEntrySubscription();
subscription.User = user;
_seeder.Add(subscription);
var subscriptionToDelete = new ColidEntrySubscriptionDto()
{
ColidPidUri = subscription.ColidPidUri
};
_repo.Delete(subscriptionToDelete);
var foundSubscription = _seeder.GetAll <ColidEntrySubscription>()
.FirstOrDefault(x => x.ColidPidUri.AbsoluteUri == subscription.ColidPidUri.AbsoluteUri);
Assert.Null(foundSubscription);
}
public ColidEntrySubscriptionServiceTests()
{
_mockSubscriptionRepository = new Mock <IColidEntrySubscriptionRepository>();
_mockLogger = new Mock <ILogger <ColidEntrySubscriptionService> >();
_subscriptionService = new ColidEntrySubscriptionService(_mockSubscriptionRepository.Object, _mockLogger.Object);
// Init testdata
_userId = Guid.NewGuid();
var builder = new ColidEntrySubscriptionBuilder().WithColidEntry(new Uri($"https://pid.bayer.com/kos19050#{Guid.NewGuid()}"));
_colidEntrySubscription = builder.Build();
_colidEntrySubscriptionDto = builder.BuildDto();
// Init mock behaviour
_mockSubscriptionRepository.Setup(x => x.GetOne(It.IsAny <Guid>(), It.IsAny <Uri>()))
.Returns(_colidEntrySubscription);
IList <User> subscribedUsers;
_mockSubscriptionRepository.Setup(x => x.TryGetAllUsers(It.IsAny <Uri>(), out subscribedUsers));
}
public ColidEntrySubscription GetOne(Guid userId, ColidEntrySubscriptionDto dto)
{
Guard.IsNotNull(dto);
return(_ceRepo.GetOne(userId, dto.ColidPidUri));
}
public void Delete_Should_ThrowException_IfArgumentIsNull()
{
ColidEntrySubscriptionDto nullDto = null;
Assert.Throws <ArgumentNullException>(() => _repo.Delete(nullDto));
}
public async Task <IActionResult> RemoveColidEntrySubscription(Guid userId, [FromBody] ColidEntrySubscriptionDto colidEntrySubscriptionDto)
{
var user = await _userService.RemoveColidEntrySubscriptionAsync(userId, colidEntrySubscriptionDto);
return(Ok(user));
}
