public async Task <string> AddRate(string courseId, Guid slideId, string userId, SlideRates rate)
{
var lastRate = db.SlideRates.FirstOrDefault(x => x.SlideId == slideId && x.UserId == userId);
if (lastRate == null)
{
db.SlideRates.Add(new SlideRate
{
Rate = rate,
UserId = userId,
SlideId = slideId,
CourseId = courseId
});
await db.SaveChangesAsync();
return("success");
}
if (lastRate.Rate == rate)
{
lastRate.Rate = SlideRates.NotWatched;
await db.SaveChangesAsync();
return("cancel");
}
lastRate.Rate = rate;
await db.SaveChangesAsync();
return("success");
}
public async Task <Comment> AddCommentAsync(string authorId, string courseId, Guid slideId, int parentCommentId, bool isForInstructorsOnly, string commentText)
{
var commentsPolicy = await commentPoliciesRepo.GetCommentsPolicyAsync(courseId).ConfigureAwait(false);
var isInstructor = await courseRolesRepo.HasUserAccessToCourseAsync(authorId, courseId, CourseRoleType.Instructor).ConfigureAwait(false);
var isApproved = commentsPolicy.ModerationPolicy == CommentModerationPolicy.Postmoderation || isInstructor;
/* Instructors' replies are automatically correct */
var isReply = parentCommentId != -1;
var isCorrectAnswer = isReply && isInstructor && !isForInstructorsOnly;
var comment = new Comment
{
AuthorId = authorId,
CourseId = courseId,
SlideId = slideId,
ParentCommentId = parentCommentId,
Text = commentText,
IsApproved = isApproved,
IsCorrectAnswer = isCorrectAnswer,
IsForInstructorsOnly = isForInstructorsOnly,
PublishTime = DateTime.Now
};
db.Comments.Add(comment);
await db.SaveChangesAsync().ConfigureAwait(false);
return(await FindCommentByIdAsync(comment.Id).ConfigureAwait(false));
}
public async Task <Group> CreateGroupAsync(
string courseId,
string name,
string ownerId,
bool isManualCheckingEnabled = false,
bool isManualCheckingEnabledForOldSolutions = false,
bool canUsersSeeGroupProgress = true,
bool defaultProhibitFurtherReview = true,
bool isInviteLinkEnabled = true)
{
logger.Information($"Создаю новую группу в курсе {courseId}: «{name}»");
var group = new Group
{
CourseId = courseId,
Name = name,
OwnerId = ownerId,
CreateTime = DateTime.Now,
IsManualCheckingEnabled = isManualCheckingEnabled,
IsManualCheckingEnabledForOldSolutions = isManualCheckingEnabledForOldSolutions,
CanUsersSeeGroupProgress = canUsersSeeGroupProgress,
DefaultProhibitFutherReview = defaultProhibitFurtherReview,
InviteHash = Guid.NewGuid(),
IsInviteLinkEnabled = isInviteLinkEnabled,
};
db.Groups.Add(group);
await db.SaveChangesAsync().ConfigureAwait(false);
return(group);
}
public async Task <AdditionalScore> SetAdditionalScore(string courseId, Guid unitId, string userId, string scoringGroupId, int score, string instructorId)
{
using (var transaction = db.Database.BeginTransaction())
{
var scores = db.AdditionalScores.Where(s => s.CourseId == courseId && s.UnitId == unitId && s.UserId == userId && s.ScoringGroupId == scoringGroupId);
db.AdditionalScores.RemoveRange(scores);
var additionalScore = new AdditionalScore
{
CourseId = courseId,
UnitId = unitId,
UserId = userId,
ScoringGroupId = scoringGroupId,
Score = score,
InstructorId = instructorId,
Timestamp = DateTime.Now,
};
db.AdditionalScores.Add(additionalScore);
transaction.Commit();
await db.SaveChangesAsync();
return(additionalScore);
}
}
public async Task <Comment> AddCommentAsync(ClaimsPrincipal author, string courseId, Guid slideId, int parentCommentId, string commentText)
{
var commentsPolicy = GetCommentsPolicy(courseId);
var isInstructor = author.HasAccessFor(courseId, CourseRole.Instructor);
var isApproved = commentsPolicy.ModerationPolicy == CommentModerationPolicy.Postmoderation || isInstructor;
/* Instructors' replies are automaticly correct */
var isReply = parentCommentId != -1;
var isCorrectAnswer = isReply && isInstructor;
var comment = new Comment
{
AuthorId = author.GetUserId(),
CourseId = courseId,
SlideId = slideId,
ParentCommentId = parentCommentId,
Text = commentText,
IsApproved = isApproved,
IsCorrectAnswer = isCorrectAnswer,
PublishTime = DateTime.Now
};
db.Comments.Add(comment);
await db.SaveChangesAsync();
return(await db.Comments.FindAsync(comment.Id));
}
public async Task AddVisit(string courseId, Guid slideId, string userId, string ipAddress)
{
courseId = courseId.ToLower();
await SetLastVisit(courseId, slideId, userId).ConfigureAwait(false);
var visit = FindVisit(courseId, slideId, userId);
if (visit == null)
{
db.Visits.Add(new Visit
{
UserId = userId,
CourseId = courseId,
SlideId = slideId,
Timestamp = DateTime.Now,
IpAddress = ipAddress,
});
}
else if (visit.IpAddress != ipAddress)
{
visit.IpAddress = ipAddress;
}
await db.SaveChangesAsync();
}
public async Task <Group> ModifyGroupAsync(
int groupId,
string newName,
bool newIsManualCheckingEnabled,
bool newIsManualCheckingEnabledForOldSolutions,
bool newDefaultProhibitFurtherReview,
bool newCanUsersSeeGroupProgress)
{
var group = await FindGroupByIdAsync(groupId).ConfigureAwait(false) ?? throw new ArgumentNullException($"Can't find group with id={groupId}");
group.Name = newName;
group.IsManualCheckingEnabled = newIsManualCheckingEnabled;
if (!group.IsManualCheckingEnabledForOldSolutions && newIsManualCheckingEnabledForOldSolutions)
{
var groupMembers = group.NotDeletedMembers.Select(m => m.UserId).ToList();
await AddManualCheckingsForOldSolutionsAsync(group.CourseId, groupMembers).ConfigureAwait(false);
}
group.IsManualCheckingEnabledForOldSolutions = newIsManualCheckingEnabledForOldSolutions;
group.DefaultProhibitFutherReview = newDefaultProhibitFurtherReview;
group.CanUsersSeeGroupProgress = newCanUsersSeeGroupProgress;
await db.SaveChangesAsync().ConfigureAwait(false);
return(group);
}
public Task SaveAccessToken(string userId, string accessToken)
{
var newToken = new StepikAccessToken
{
AccessToken = accessToken,
UserId = userId,
AddedTime = DateTime.Now
};
var oldUsersTokens = db.StepikAccessTokens.Where(t => t.UserId == userId).ToList();
db.StepikAccessTokens.RemoveRange(oldUsersTokens);
db.StepikAccessTokens.Add(newToken);
return db.SaveChangesAsync();
}
public async Task ChangeTelegram(string userId, long chatId, string chatTitle)
{
var user = FindUserById(userId);
if (user == null)
{
return;
}
user.TelegramChatId = chatId;
user.TelegramChatTitle = chatTitle;
await db.SaveChangesAsync();
}
public async Task <UserExerciseSubmission> AddUserExerciseSubmission(
string courseId, Guid slideId,
string code, string compilationError, string output,
string userId, string executionServiceName, string displayName,
AutomaticExerciseCheckingStatus status = AutomaticExerciseCheckingStatus.Waiting)
{
if (string.IsNullOrWhiteSpace(code))
{
code = "// no code";
}
var hash = (await textsRepo.AddText(code)).Hash;
var compilationErrorHash = (await textsRepo.AddText(compilationError)).Hash;
var outputHash = (await textsRepo.AddText(output)).Hash;
var automaticChecking = new AutomaticExerciseChecking
{
CourseId = courseId,
SlideId = slideId,
UserId = userId,
Timestamp = DateTime.Now,
CompilationErrorHash = compilationErrorHash,
IsCompilationError = !string.IsNullOrWhiteSpace(compilationError),
OutputHash = outputHash,
ExecutionServiceName = executionServiceName,
DisplayName = displayName,
Status = status,
IsRightAnswer = false,
};
db.AutomaticExerciseCheckings.Add(automaticChecking);
var submission = new UserExerciseSubmission
{
CourseId = courseId,
SlideId = slideId,
UserId = userId,
Timestamp = DateTime.Now,
SolutionCodeHash = hash,
CodeHash = code.Split('\n').Select(x => x.Trim()).Aggregate("", (x, y) => x + y).GetHashCode(),
Likes = new List <Like>(),
AutomaticChecking = automaticChecking,
AutomaticCheckingIsRightAnswer = false,
};
db.UserExerciseSubmissions.Add(submission);
await db.SaveChangesAsync();
return(submission);
}
public async Task AddHint(string userId, int hintId, string courseId, Guid slideId)
{
if (db.Hints.Any(x => x.UserId == userId && x.HintId == hintId && x.SlideId == slideId))
{
return;
}
db.Hints.Add(new SlideHint
{
UserId = userId,
HintId = hintId,
CourseId = courseId,
SlideId = slideId
});
await db.SaveChangesAsync();
}
public async Task <UserQuizSubmission> AddSubmissionAsync(string courseId, Guid slideId, string userId, DateTime timestamp)
{
var submission = new UserQuizSubmission
{
CourseId = courseId,
SlideId = slideId,
UserId = userId,
Timestamp = timestamp,
};
db.UserQuizSubmissions.Add(submission);
await db.SaveChangesAsync().ConfigureAwait(false);
return(submission);
}
public async Task AddVisit(string courseId, Guid slideId, string userId)
{
if (IsUserVisitedSlide(courseId, slideId, userId))
{
return;
}
db.Visits.Add(new Visit
{
UserId = userId,
CourseId = courseId,
SlideId = slideId,
Timestamp = DateTime.Now
});
await db.SaveChangesAsync();
}
public async Task <CourseVersion> AddCourseVersionAsync(string courseId, Guid versionId, string authorId)
{
var courseVersion = new CourseVersion
{
Id = versionId,
CourseId = courseId,
LoadingTime = DateTime.Now,
PublishTime = null,
AuthorId = authorId,
};
db.CourseVersions.Add(courseVersion);
await db.SaveChangesAsync().ConfigureAwait(false);
return(courseVersion);
}
public async Task Add(int queueId, string itemId, string type, int priority = 0)
{
db.WorkQueueItems.Add(new WorkQueueItem {
QueueId = queueId, ItemId = itemId, Type = type, Priority = priority
});
await db.SaveChangesAsync();
}
public async Task <bool> ToggleRole(string courseId, string userId, CourseRoleType roleType, string grantedById, string comment)
{
var userRoles = await db.CourseRoles.ToListAsync();
var userRole = userRoles.LastOrDefault(u => u.UserId == userId && u.Role == roleType && string.Equals(u.CourseId, courseId, StringComparison.OrdinalIgnoreCase));
bool isEnabled;
if (userRole != null && (!userRole.IsEnabled.HasValue || userRole.IsEnabled.Value))
{
isEnabled = false;
}
else
{
isEnabled = true;
}
db.CourseRoles.Add(new CourseRole
{
UserId = userId,
CourseId = courseId,
Role = roleType,
IsEnabled = isEnabled,
GrantedById = grantedById,
GrantTime = DateTime.Now.ToUniversalTime(),
Comment = comment
});
await db.SaveChangesAsync();
return(isEnabled);
}
public async Task <ManualQuizChecking> AddManualQuizChecking(UserQuizSubmission submission, string courseId, Guid slideId, string userId)
{
var manualChecking = new ManualQuizChecking
{
Submission = submission,
CourseId = courseId,
SlideId = slideId,
UserId = userId,
Timestamp = DateTime.Now,
};
db.ManualQuizCheckings.Add(manualChecking);
await db.SaveChangesAsync();
return(manualChecking);
}
public async Task SaveCommentsPolicyAsync(CommentsPolicy policy)
{
using (var transaction = db.Database.BeginTransaction())
{
await db.CommentsPolicies.Where(x => x.CourseId == policy.CourseId).DeleteAsync().ConfigureAwait(false);
db.CommentsPolicies.Add(policy);
await db.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
}
public async Task <SystemAccess> GrantAccessAsync(string userId, SystemAccessType accessType, string grantedById)
{
var currentAccess = await db.SystemAccesses.FirstOrDefaultAsync(a => a.UserId == userId && a.AccessType == accessType).ConfigureAwait(false);
if (currentAccess == null)
{
currentAccess = new SystemAccess
{
UserId = userId,
AccessType = accessType,
};
db.SystemAccesses.Add(currentAccess);
}
currentAccess.GrantedById = grantedById;
currentAccess.GrantTime = DateTime.Now;
currentAccess.IsEnabled = true;
await db.SaveChangesAsync().ConfigureAwait(false);
return(db.SystemAccesses.Include(a => a.GrantedBy).Single(a => a.Id == currentAccess.Id));
}
public async Task <Visit> AddVisit(string courseId, Guid slideId, string userId, string ipAddress)
{
await SetLastVisit(courseId, slideId, userId);
var visit = await FindVisit(courseId, slideId, userId);
if (visit == null)
{
db.Visits.Add(new Visit
{
UserId = userId,
CourseId = courseId,
SlideId = slideId,
Timestamp = DateTime.Now,
IpAddress = ipAddress,
});
await db.SaveChangesAsync();
return(await FindVisit(courseId, slideId, userId));
}
if (visit.IpAddress != ipAddress)
{
visit.IpAddress = ipAddress;
}
await db.SaveChangesAsync();
return(visit);
}
public async Task AddNotificationTransport(NotificationTransport transport)
{
using (var transaction = db.Database.BeginTransaction())
{
await DeleteOldNotificationTransports(transport.GetType(), transport.UserId);
transport.IsDeleted = false;
db.NotificationTransports.Add(transport);
await db.SaveChangesAsync();
await transaction.CommitAsync();
}
}
public async Task <TextBlob> AddText(string text)
{
if (text == null)
{
return new TextBlob
{
Hash = null,
Text = null
}
}
;
if (text.Length > MaxTextSize)
{
text = text.Substring(0, MaxTextSize);
}
if (text.Contains('\0'))
{
text = text.Replace("\0", ""); // postgres не поддерживает \0 в строках
}
var hash = GetHash(text);
var blob = await db.Texts.FindAsync(hash);
if (blob != null)
{
return(blob);
}
blob = new TextBlob
{
Hash = hash,
Text = text
};
db.AddOrUpdate(blob, b => b.Hash == hash);
try
{
await db.SaveChangesAsync().ConfigureAwait(false);
}
catch (DbUpdateException)
{
// It's ok, just tried to insert text with hash which already exists, try to find it
if (!db.Texts.AsNoTracking().Any(t => t.Hash == hash))
{
throw;
}
db.Entry(blob).State = EntityState.Unchanged;
}
return(blob);
}
public async Task <string> CreateRequest(string userId)
{
var previousRequests = db.RestoreRequests.Where(r => r.UserId == userId).ToList();
if (previousRequests.Any())
{
var hasRecent = false;
foreach (var previous in previousRequests)
{
if (DateTime.Now.Subtract(previous.Timestamp) < TimeSpan.FromMinutes(5))
{
hasRecent = true;
}
else
{
db.RestoreRequests.Remove(previous);
}
}
if (hasRecent)
{
await db.SaveChangesAsync();
return(null);
}
}
var request = new RestoreRequest
{
Id = Guid.NewGuid().ToString(),
UserId = userId,
Timestamp = DateTime.Now
};
db.RestoreRequests.Add(request);
await db.SaveChangesAsync();
return(request.Id);
}
public async Task <GraderClient> AddGraderClient(string courseId, string name)
{
var clientId = Guid.NewGuid();
var user = new ApplicationUser {
UserName = $"__grader_client_{clientId.GetNormalizedGuid()}__"
};
var password = StringUtils.GenerateSecureAlphanumericString(10);
await userManager.CreateAsync(user, password);
var client = new GraderClient
{
Id = clientId,
CourseId = courseId,
Name = name,
User = user,
};
db.GraderClients.Add(client);
await db.SaveChangesAsync();
return(client);
}
public async Task <UserFlashcardsVisit> AddFlashcardVisitAsync(string userId, string courseId, Guid unitId, string flashcardId, Rate rate, DateTime timestamp)
{
courseId = courseId.ToLower();
var record = new UserFlashcardsVisit
{
UserId = userId, CourseId = courseId, UnitId = unitId, FlashcardId = flashcardId, Rate = rate, Timestamp = timestamp
};
db.UserFlashcardsVisits.Add(record);
await db.SaveChangesAsync();
return(await GetUserFlashcardVisitAsync(userId, courseId, unitId, flashcardId));
}
public async Task AddXQueueWatcher(string name, string baseUrl, string queueName, string username, string password)
{
var user = new ApplicationUser {
UserName = $"__xqueue_watcher_{new Guid().GetNormalizedGuid()}__"
};
var userPassword = StringUtils.GenerateSecureAlphanumericString(10);
await userManager.CreateAsync(user, userPassword);
var watcher = new XQueueWatcher
{
Name = name,
BaseUrl = baseUrl,
QueueName = queueName,
UserName = username,
Password = password,
IsEnabled = true,
User = user,
};
db.XQueueWatchers.Add(watcher);
await db.SaveChangesAsync();
}
public async Task <UserFlashcardsUnlocking> AddUserFlashcardsUnlocking(string userId, Course course, Unit unit)
{
var courseId = course.Id.ToLower();
var record = new UserFlashcardsUnlocking()
{
UserId = userId, CourseId = courseId, UnitId = unit.Id
};
db.UserFlashcardsUnlocking.Add(record);
await db.SaveChangesAsync();
return(await GetUserFlashcardsUnlocking(userId, course, unit));
}
public async Task <GroupMember> AddUserToGroupAsync(int groupId, string userId)
{
logger.Information($"Пытаюсь добавить пользователя {userId} в группу {groupId}");
var group = await groupsRepo.FindGroupByIdAsync(groupId).ConfigureAwait(false) ?? throw new ArgumentNullException($"Can't find group with id={groupId}");
var groupMember = new GroupMember
{
GroupId = groupId,
UserId = userId,
AddingTime = DateTime.Now,
};
using (var transaction = db.Database.BeginTransaction())
{
/* Don't add member if it's already exists */
var existsMember = db.GroupMembers.FirstOrDefault(m => m.GroupId == groupId && m.UserId == userId);
if (existsMember != null)
{
logger.Information($"Пользователь {userId} уже находится в группе {groupId}, повторно добавлять не буду");
return(null);
}
db.GroupMembers.Add(groupMember);
await db.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
logger.Information($"Пользователь {userId} добавлен в группу {groupId}");
}
if (group.IsManualCheckingEnabledForOldSolutions)
{
await manualCheckingsForOldSolutionsAdder.AddManualCheckingsForOldSolutionsAsync(group.CourseId, userId).ConfigureAwait(false);
}
return(groupMember);
}
public async Task <UserQuiz> AddUserQuiz(string courseId, bool isRightAnswer, string itemId, string quizId, Guid slideId, string text, string userId, DateTime time, int quizBlockScore, int quizBlockMaxScore)
{
var quizzesRepo = new QuizzesRepo(db);
var currentQuizVersion = quizzesRepo.GetLastQuizVersion(courseId, slideId);
var userQuiz = new UserQuiz
{
CourseId = courseId,
SlideId = slideId,
QuizVersionId = currentQuizVersion.Id,
IsRightAnswer = isRightAnswer,
ItemId = itemId,
QuizId = quizId,
Text = text,
Timestamp = time,
UserId = userId,
QuizBlockScore = quizBlockScore,
QuizBlockMaxScore = quizBlockMaxScore
};
db.UserQuizzes.Add(userQuiz);
await db.SaveChangesAsync();
return(userQuiz);
}
public async Task <TempCourse> AddTempCourseAsync(string courseId, string authorId)
{
var tempCourse = new TempCourse
{
CourseId = courseId,
AuthorId = authorId,
LoadingTime = DateTime.Now,
LastUpdateTime = DateTime.UnixEpoch // Используется вместо default, потому что default нельзя сохранить в базу
};
db.TempCourses.Add(tempCourse);
await db.SaveChangesAsync();
return(tempCourse);
}