public async Task AddVersionAsync(uint userId, IFormFile workFile, bool isFirstVersion = false)
{
byte versionNumber = 1;
if (!isFirstVersion)
{
versionNumber = await _scientificWorkRepository.GetNumberOfVersionsByAuthorIdAsync(userId);
versionNumber++;
}
var scientificWork = await _scientificWorkRepository.GetByAuthorIdAsync(userId);
var workName = await _fileManager.SaveFileAsync(workFile);
var versionOfWork = new ScientificWorkFile()
{
Version = versionNumber,
FileName = workName,
DateAdd = DateTime.Now,
ScientificWork = scientificWork
};
await _scientificWorkFileRepository.AddAsync(versionOfWork);
// change status when the work reviewed before
if (!isFirstVersion)
{
scientificWork.Status = StatusEnum.UnderReview;
await _scientificWorkRepository.ChangeStatusAsync(scientificWork);
var emailsOfReviewers = await _reviewersWorkRepository.GetEmailsOfReviewersByWorkIdAsync(scientificWork.Id);
foreach (var email in emailsOfReviewers)
{
await _emailSender.SendAddedNewVersionEmailAsync(email, scientificWork.Id);
}
}
}
public async Task AssignReviewersToScientificWorkAsync()
{
var categories = new[] { "Computer Science", "Mathematics", "Biology", "Chemistry", "Psychics", "Geography" };
foreach (var category in categories)
{
// get reviewers and scientific works
var scientificWorks = await _scientificWorkRepository.GetAllBySpecializationAsync(category);
var reviewers = await _userRepository.GetAllBySpecializationAsync(category);
// get work's ids
// and
// try to find id of reviewer which register with same email as author of the work
// when author (probably) has one account, assign 0 as id
var scientificWorkIds = scientificWorks.Select(x =>
(
id: x.Id,
authorAsReviewerId: reviewers.SingleOrDefault(y => y.NormalizedEmail == x.MainAuthor.NormalizedEmail)?.Id ?? 0
)).ToArray();
var reviewerIds = reviewers.Select(x => x.Id).ToArray();
// send information to authors/reviewers about too small number of works/reviewers
// and set status to rejected
if (reviewerIds.Length < 4 || scientificWorkIds.Length < 4)
{
for (var i = 0; i < reviewerIds.Length; i++)
{
var reviewerEmail = _userRepository.GetEmailById(reviewerIds[i]);
await _emailSender.SendDoNotGetAssignToAnyWork(reviewerEmail);
}
foreach (var scientificWork in scientificWorks)
{
await _emailSender.SendWorkDidNotGetReviewers(scientificWork.MainAuthor.Email);
scientificWork.Status = StatusEnum.Rejected;
await _scientificWorkRepository.ChangeStatusAsync(scientificWork);
}
continue;
}
var scientificWoksWithReviewers = RandomizeReviewers(scientificWorkIds, reviewerIds);
// save assignment to db
var reviewersScientificWorks = new List <ReviewersScienceWork>();
foreach (var(workId, reviewersId) in scientificWoksWithReviewers)
{
for (var i = 0; i < reviewersId.Count; i++)
{
reviewersScientificWorks.Add(new ReviewersScienceWork()
{
ScientificWork = scientificWorks.Single(x => x.Id == workId),
User = reviewers.Single(x => x.Id == reviewersId[i])
});
// send email to reviewer about work to review
var reviewerEmail = _userRepository.GetEmailById(reviewersId[i]);
await _emailSender.SendWorkAssignmentInformationAsync(reviewerEmail, workId);
}
}
// send email to author of the work about assigned reviewers
// and change status to UnderReview
foreach (var scientificWork in scientificWorks)
{
await _emailSender.SendReviewersAssignmentInformationAsync(scientificWork.MainAuthor.Email, scientificWork.Id);
scientificWork.Status = StatusEnum.UnderReview;
await _scientificWorkRepository.ChangeStatusAsync(scientificWork);
}
await _reviewersScientificWorkRepository.AddAsync(reviewersScientificWorks);
}
}
public async Task AddReviewAsync(uint reviewerId, string reviewMsg, IFormFile reviewFile, byte rating, uint scientificWorkId)
{
// check if user is a reviewer for given ScientificWork
var isReviewerOfScientificWork = await _scientificWorkRepository.IsReviewerOfScientificWorkAsync(reviewerId, scientificWorkId);
if (!isReviewerOfScientificWork)
{
return;
}
// check if review exists
var newestVersion = await _scientificWorkFileRepository.GetNewestVersionWithReviewsAsync(scientificWorkId);
var isReviewAdded = newestVersion.Reviews.Any(x => x.Reviewer.Id == reviewerId);
if (isReviewAdded)
{
return;
}
var reviewer = await _userManager.FindByIdAsync(reviewerId.ToString());
var review = new Review()
{
VersionOfScientificWork = newestVersion,
Reviewer = reviewer,
DateReview = DateTime.Now,
Rating = rating,
};
// add file only when it's not null
if (!(reviewFile is null))
{
review.File = await _fileManager.SaveFileAsync(reviewFile);
}
// when reviewer doesn't write message
// it's just assign null (nothing change)
review.Comment = reviewMsg;
await _reviewRepository.AddReviewAsync(review);
var reviewerCount = _reviewersWorkRepository.GetReviewersCount(scientificWorkId);
var reviewsCount = _scientificWorkFileRepository.GetReviewsCountInNewestVersion(scientificWorkId);
var emailOfAuthor = await _scientificWorkRepository.GetEmailOfAuthorByWorkIdAsync(scientificWorkId);
// all reviewers added their reviews
if (reviewsCount == reviewerCount)
{
var sumOfRating = await _scientificWorkFileRepository.GetRatingSumFromVersion(newestVersion.Id);
var ratingAvg = (float)sumOfRating / reviewerCount;
var work = await _scientificWorkRepository.GetWorkByIdAsync(scientificWorkId);
if (ratingAvg < 1.5)
{
work.Status = StatusEnum.Rejected;
newestVersion.Rating = 1;
await _emailSender.SendToAuthorWorkGotRejectedAsync(emailOfAuthor, scientificWorkId);
}
else if (ratingAvg <= 2.5)
{
work.Status = StatusEnum.Correcting;
newestVersion.Rating = 2;
await _emailSender.SendNewVersionEnabledEmailAsync(emailOfAuthor, scientificWorkId);
}
else
{
work.Status = StatusEnum.Accepted;
newestVersion.Rating = 3;
await _emailSender.SendToAuthorWorkGotAcceptedAsync(emailOfAuthor, scientificWorkId);
}
await _scientificWorkRepository.ChangeStatusAsync(work);
await _scientificWorkFileRepository.AddRatingAsync(newestVersion);
}
else
{
await _emailSender.SendReceiveReviewEmailAsync(emailOfAuthor, scientificWorkId);
}
}
