private void ValidateNotNullSubscription(SourceSubscription subscription)
{
if (subscription == null)
{
throw new NullSubscriptionException();
}
}
private void ValidateSubscription(SourceSubscription subscription, int subscriptionId)
{
if (subscription == null)
{
throw new NotFoundSubscriptionException(subscriptionId);
}
}
public async void ShouldThrowValidationExceptionOnUpdateWhenStorageSubscriptionIsNullAsync()
{
// arrange
var randomSubscription = GetRandomSubscription();
var inputSubscription = randomSubscription;
var inputSubscriptionId = randomSubscription.Id;
SourceSubscription invalidSubscription = null;
var notFoundSubscriptionException = new NotFoundSubscriptionException(inputSubscriptionId);
var expectedValidationException =
new SubscriptionValidationException(notFoundSubscriptionException);
_storageBrokerMock.Setup(broker =>
broker.SelectSourceSubscriptionByIdAsync(inputSubscriptionId))
.ReturnsAsync(invalidSubscription);
// act
var actualSubscriptionTask = _subscriptionService.UpdateSubscriptionAsync(inputSubscription);
// assert
var actualException = await Assert.ThrowsAsync <SubscriptionValidationException>(() =>
actualSubscriptionTask);
Assert.Equal(expectedValidationException.Message, actualException.Message);
Assert.IsType <NotFoundSubscriptionException>(actualException.InnerException);
Assert.Equal(expectedValidationException.InnerException.Message, actualException.InnerException.Message);
_storageBrokerMock.Verify(broker =>
broker.SelectSourceSubscriptionByIdAsync(inputSubscriptionId),
Times.Once);
_storageBrokerMock.VerifyNoOtherCalls();
}
public async Task <SourceSubscription> DeleteSourceSubscriptionAsync(SourceSubscription sourceSubscription)
{
var sourceSubscriptionEntry = SourceSubscriptions.Remove(sourceSubscription);
await SaveChangesAsync();
return(sourceSubscriptionEntry.Entity);
}
public async Task <SourceSubscription> UpdateSourceSubscriptionAsync(SourceSubscription sourceSubscription)
{
sourceSubscription.UpdateDate = DateTimeOffset.Now;
var sourceSubscriptionEntry = SourceSubscriptions.Update(sourceSubscription);
await SaveChangesAsync();
await Entry(sourceSubscriptionEntry.Entity).Reference(r => r.SourceType).LoadAsync();
return(sourceSubscriptionEntry.Entity);
}
public Task <SourceSubscription> AddSubscriptionAsync(SourceSubscription subscription)
{
return(TryCatch(async() =>
{
ValidateSubscriptionOnAdd(subscription);
subscription.Id = 0;
var storageSubscription = await _storageBroker.InsertSourceSubscriptionAsync(subscription);
await UpdateSubscriptionVacanciesAsync(storageSubscription);
return storageSubscription;
}));
}
private async Task SaveSubscriptionVacancy(Vacancy vacancy, SourceSubscription subscription)
{
var subscriptionVacancy = new SubscriptionVacancy
{
SourceSubscriptionId = subscription.Id,
VacancyId = vacancy.Id
};
await _storageBroker.InsertSubscriptionVacancyAsync(subscriptionVacancy);
_logger.Log(LogLevel.Information, "Saved subscription vacancy {VacancyId} for subscription {SubscriptionId}",
vacancy.Id, subscription.Id);
}
public Task <SourceSubscription> UpdateSubscriptionAsync(SourceSubscription subscription)
{
return(TryCatch(async() =>
{
ValidateSubscriptionOnUpdate(subscription);
var storageSubscription = await _storageBroker.SelectSourceSubscriptionByIdAsync(subscription.Id);
ValidateStorageSubscription(storageSubscription, subscription.Id);
var updatedSubscription = await _storageBroker.UpdateSourceSubscriptionAsync(subscription);
if (updatedSubscription.Parameters != storageSubscription.Parameters)
{
await _syncSubscriptionService.UpdateSubscription(storageSubscription.Id);
}
return updatedSubscription;
}));
}
public async void ShouldThrowValidationExceptionOnUpdateWhenInputSubscriptionIsNullAsync()
{
// arrange
SourceSubscription nullInputSubscription = null;
var nullSubscriptionException = new NullSubscriptionException();
var expectedValidationException =
new SubscriptionValidationException(nullSubscriptionException);
// act
var actualSubscriptionTask = _subscriptionService.UpdateSubscriptionAsync(nullInputSubscription);
// assert
var actualException = await Assert.ThrowsAsync <SubscriptionValidationException>(() =>
actualSubscriptionTask);
Assert.Equal(expectedValidationException.Message, actualException.Message);
Assert.IsType <NullSubscriptionException>(actualException.InnerException);
Assert.Equal(expectedValidationException.InnerException.Message, actualException.InnerException.Message);
_storageBrokerMock.VerifyNoOtherCalls();
}
private void ValidateSubscriptionOnAdd(SourceSubscription subscription)
{
ValidateNotNullSubscription(subscription);
}
private async Task UpdateSubscriptionVacancies(SourceSubscription subscription)
{
_logger.LogInformation("Processing subscription with id {SubscriptionId}",
subscription.Id);
var sourceType = subscription.SourceType;
var subscriptionParameters = GetSubscriptionParameters(subscription.Parameters);
var snippets = _headHunterBroker.GetSnippets(subscriptionParameters);
// for each subscription load vacancies
var count = 0;
await foreach (var snippet in snippets)
{
_logger.Log(LogLevel.Information, "Processing vacancy #{VacancyOderNumber}", count);
var existedVacancy = await _storageBroker.SelectVacancyBySourceIdAsync(sourceType.Id, snippet.Id);
if (existedVacancy == null)
{
_logger.Log(LogLevel.Information, "Adding vacancy #{VacancyOderNumber}", count);
var headHunterVacancy = await _headHunterBroker.GetVacancy(snippet.Id);
var vacancy = await CreateVacancyAsync(sourceType, snippet, headHunterVacancy);
vacancy = await _storageBroker.InsertVacancyAsync(vacancy);
var vacancySkills = await CreateVacancySkillsAsync(vacancy, headHunterVacancy.KeySkills);
await SaveVacancySkillsAsync(vacancySkills);
await SaveSubscriptionVacancy(vacancy, subscription);
}
else
{
if (existedVacancy.SourceUpdatedDate < snippet.UpdateDate ||
existedVacancy.IsArchived != snippet.Archived)
{
_logger.Log(LogLevel.Information, "Updating vacancy #{VacancyOderNumber}", count);
var headHunterVacancy = await _headHunterBroker.GetVacancy(snippet.Id);
var updatedVacancy = await CreateVacancyAsync(sourceType, snippet, headHunterVacancy);
updatedVacancy.Id = existedVacancy.Id;
if (!existedVacancy.HasContentChanges(updatedVacancy))
{
updatedVacancy.ContentUpdatedDate = existedVacancy.ContentUpdatedDate;
}
await _storageBroker.UpdateVacancyAsync(updatedVacancy);
}
var subscriptionVacancy = await
_storageBroker.SelectSubscriptionVacancyByVacancyAndSubscriptionIdAsync(subscription.Id,
existedVacancy.Id);
if (subscriptionVacancy == null)
{
await SaveSubscriptionVacancy(existedVacancy, subscription);
}
}
count++;
}
_logger.LogInformation("Subscription with id {SubscriptionId} was updated",
subscription.Id);
}
private static IEnumerable <SubscriptionVacancy> GetSeedingSubscriptionVacancies(SourceSubscription subscription)
{
var subscriptionVacancies = _subscriptionVacancyFaker.Generate(25);
subscriptionVacancies.ForEach(sv => sv.SourceSubscriptionId = subscription.Id);
return(subscriptionVacancies);
}
public async Task UpdateSubscriptionVacanciesAsync(SourceSubscription subscription)
{
await _syncSubscriptionService.UpdateSubscription(subscription.Id);
}
