public override async Task ReassignCourseSpecializationsAsync(UpdateDbContext context, bool useArchiveData = false)
{
if (!IsInitialized)
{
throw new InvalidOperationException(Resources.InvalidOperation_PluralsightCatalog_InitializeMethodInvokeRequired);
}
if (context == null)
{
throw new ArgumentNullException("context");
}
var allCourses = await context.Courses
.Where(x => x.TrainingProviderId == TrainingProviderId && !x.IsDeleted)
.Select(x => new
{
x.Id,
x.UrlName,
CourseSpecializations = x.CourseSpecializations.ToList()
})
.AsNoTracking()
.ToListAsync();
var courseSpecializationsContainer = await GetCourseSpecializationsContainerAsync(useArchiveData);
try
{
context.Configuration.AutoDetectChangesEnabled = false;
foreach (var dbCourse in allCourses)
{
Specializations specializationsForCourse;
if (courseSpecializationsContainer.TryGetValue(dbCourse.UrlName, out specializationsForCourse))
{
var currentSpecializations = specializationsForCourse.GetFlags <Specializations>().ToList();
foreach (var dbCourseSpecialization in dbCourse.CourseSpecializations)
{
if (currentSpecializations.Contains(dbCourseSpecialization.Specialization))
{
currentSpecializations.Remove(dbCourseSpecialization.Specialization);
}
else
{
context.SetStateToDeleted(dbCourseSpecialization);
}
}
foreach (var specialization in currentSpecializations)
{
var courseSpecialization = new CourseSpecialization
{
CourseId = dbCourse.Id,
Specialization = specialization
};
context.SetStateToAdded(courseSpecialization);
}
}
}
}
finally
{
context.Configuration.AutoDetectChangesEnabled = true;
}
await context.SaveChangesAsync();
}
private async Task ApplayAuthorResolve(AuthorResolve currentAuthorResolve, int resolvedId, string resolvedUrl, string resolvedUrlName)
{
currentAuthorResolve.ResolveState = ResolveState.Resolved;
currentAuthorResolve.ResolvedAuthorId = resolvedId;
currentAuthorResolve.AuthorSiteUrl = resolvedUrl;
currentAuthorResolve.AuthorUrlName = resolvedUrlName;
var trainingProviderAuthor = await _db.TrainingProviderAuthors
.SingleOrDefaultAsync(x => x.TrainingProviderId == currentAuthorResolve.TrainingProviderId && x.AuthorId == resolvedId);
if (trainingProviderAuthor == null)
{
trainingProviderAuthor = new TrainingProviderAuthor
{
TrainingProviderId = currentAuthorResolve.TrainingProviderId,
AuthorId = resolvedId,
FullName = currentAuthorResolve.AuthorFullName,
SiteUrl = currentAuthorResolve.AuthorSiteUrl,
UrlName = currentAuthorResolve.AuthorUrlName
};
_db.TrainingProviderAuthors.Add(trainingProviderAuthor);
}
else if (trainingProviderAuthor.IsDeleted)
{
trainingProviderAuthor.IsDeleted = false;
}
var courseAuthor = await _db.CourseAuthors
.SingleOrDefaultAsync(x => x.CourseId == currentAuthorResolve.CourseId && x.AuthorId == resolvedId);
if (courseAuthor == null)
{
courseAuthor = new CourseAuthor
{
TrainingProviderId = currentAuthorResolve.TrainingProviderId,
AuthorId = resolvedId,
CourseId = currentAuthorResolve.CourseId,
IsAuthorCoAuthor = currentAuthorResolve.IsAuthorCoAuthor
};
_db.CourseAuthors.Add(courseAuthor);
}
else if (courseAuthor.IsDeleted)
{
courseAuthor.IsDeleted = false;
}
await _db.SaveChangesAsync();
var unresolvedAuthorCount = await _db.AuthorsResolves
.CountAsync(x => x.UpdateEventId == currentAuthorResolve.UpdateEventId && x.ResolveState == ResolveState.Pending);
if (unresolvedAuthorCount == 0)
{
var currentUpdateEvent = await _db.UpdateEvents
.SingleOrDefaultAsync(x => x.Id == currentAuthorResolve.UpdateEventId && x.UpdateResult == UpdateResult.NeedManualResolve);
if (currentUpdateEvent != null)
{
currentUpdateEvent.UpdateResult = UpdateResult.Resolved;
await _db.SaveChangesAsync();
}
}
}