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 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 AddVisit(string courseId, Guid slideId, string userId, string ipAddress)
{
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 <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 <TextBlob> AddText(string text)
{
if (text == null)
{
return new TextBlob
{
Hash = null,
Text = null
}
}
;
if (text.Length > MaxTextSize)
{
text = text.Substring(0, MaxTextSize);
}
var hash = GetHash(text);
var blob = db.Texts.Find(hash);
if (blob != null)
{
return(blob);
}
blob = new TextBlob
{
Hash = hash,
Text = text
};
db.Texts.AddOrUpdate(blob);
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 UpdateFeedViewTimestamp(string userId, int transportId, DateTime timestamp)
{
var currentTimestamp = db.FeedViewTimestamps.FirstOrDefault(t => t.UserId == userId && t.TransportId == transportId);
if (currentTimestamp == null)
{
currentTimestamp = new FeedViewTimestamp
{
UserId = userId,
TransportId = transportId,
};
db.FeedViewTimestamps.Add(currentTimestamp);
}
currentTimestamp.Timestamp = timestamp;
await db.SaveChangesAsync();
}
public async Task <CertificateTemplate> AddTemplate(string courseId, string name, string archiveName)
{
var template = new CertificateTemplate
{
Id = Guid.NewGuid(),
CourseId = courseId,
Name = name,
Timestamp = DateTime.Now,
ArchiveName = archiveName,
};
db.CertificateTemplates.Add(template);
await db.SaveChangesAsync();
return(template);
}
public async Task AddNotificationTransport(NotificationTransport transport)
{
using (var transaction = db.Database.BeginTransaction())
{
DeleteOldNotificationTransports(transport.GetType(), transport.UserId);
/*
* if (transport is MailNotificationTransport)
* DeleteOldNotificationTransports<MailNotificationTransport>(transport.UserId);
* if (transport is TelegramNotificationTransport)
* DeleteOldNotificationTransports<TelegramNotificationTransport>(transport.UserId);
*/
transport.IsDeleted = false;
db.NotificationTransports.Add(transport);
await db.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
}
public async Task EnableStyleErrorAsync(StyleErrorType errorType, bool isEnabled)
{
var oldSettings = await db.StyleErrorSettings.FirstOrDefaultAsync(s => s.ErrorType == errorType);
if (oldSettings == null)
{
db.StyleErrorSettings.Add(new StyleErrorSettings
{
ErrorType = errorType,
IsEnabled = isEnabled,
});
}
else
{
oldSettings.IsEnabled = isEnabled;
}
await db.SaveChangesAsync();
}
public async Task <bool> ToggleRole(string courseId, string userId, CourseRole role)
{
var userRole = db.UserRoles.FirstOrDefault(u => u.UserId == userId && u.Role == role && u.CourseId == courseId);
if (userRole == null)
{
db.UserRoles.Add(new UserRole
{
UserId = userId,
CourseId = courseId,
Role = role
});
}
else
{
db.UserRoles.Remove(userRole);
}
await db.SaveChangesAsync();
return(userRole == null);
}
public async Task <CourseVersion> AddCourseVersion(string courseId, Guid versionId, string authorId,
string pathToCourseXml, string repoUrl, string commitHash, string description)
{
var courseVersion = new CourseVersion
{
Id = versionId,
CourseId = courseId,
LoadingTime = DateTime.Now,
PublishTime = null,
AuthorId = authorId,
PathToCourseXml = pathToCourseXml,
CommitHash = commitHash,
Description = description,
RepoUrl = repoUrl
};
db.CourseVersions.Add(courseVersion);
await db.SaveChangesAsync();
return(courseVersion);
}
public async Task <UserExerciseSubmission> AddUserExerciseSubmission(
string courseId, Guid slideId,
string code, string compilationError, string output,
string userId, string executionServiceName, string displayName,
SubmissionLanguage language,
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;
AutomaticExerciseChecking automaticChecking;
if (language.HasAutomaticChecking())
{
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);
}
else
{
automaticChecking = null;
}
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 = automaticChecking?.IsRightAnswer ?? true,
Language = language,
};
db.UserExerciseSubmissions.Add(submission);
await db.SaveChangesAsync();
return(submission);
}
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().ConfigureAwait(false);
return(manualChecking);
}
public async Task AddQuizAttemptForManualChecking(string courseId, Guid slideId, string userId)
{
var manualChecking = new ManualQuizChecking
{
CourseId = courseId,
SlideId = slideId,
UserId = userId,
Timestamp = DateTime.Now,
};
db.ManualQuizCheckings.Add(manualChecking);
await db.SaveChangesAsync();
}
public async Task <Group> CreateGroup(string courseId, string name, string ownerId, bool isManualCheckingEnabled = false, bool isManualCheckingEnabledForOldSolutions = false)
{
var group = new Group
{
CourseId = courseId,
Name = name,
OwnerId = ownerId,
IsManualCheckingEnabled = isManualCheckingEnabled,
IsManualCheckingEnabledForOldSolutions = isManualCheckingEnabledForOldSolutions,
};
db.Groups.Add(group);
await db.SaveChangesAsync();
return(group);
}
