public override async Task <GetOfflineDictionariesRequest> HandleAsync(GetOfflineDictionariesRequest command, CancellationToken cancellationToken = new CancellationToken())
{
var dictionaries = await _queryProcessor.ExecuteAsync(new GetOfflineDictionariesQuery(), cancellationToken);
var localDictionaries = await _queryProcessor.ExecuteAsync(new GetLocalDictionariesQuery(), cancellationToken);
foreach (var dictionary in dictionaries.Items)
{
var isDownloading = await _queryProcessor.ExecuteAsync(new GetDictionaryDownloadJobQuery(dictionary.Id));
dictionary.IsDownloading = isDownloading;
if (localDictionaries.Items.Any(d => d.Id == dictionary.Id))
{
dictionary.IsOffline = true;
}
}
command.Result = _dictionariesRenderer.Render(dictionaries);
return(await base.HandleAsync(command, cancellationToken));
}
public override async Task <GetRelationshipsByWordRequest> HandleAsync(GetRelationshipsByWordRequest command, CancellationToken cancellationToken = new CancellationToken())
{
var query = new GetRelationshipsByWordIdQuery
{
DictionaryId = command.DictionaryId,
WordId = command.WordId
};
var result = await _queryProcessor.ExecuteAsync(query, cancellationToken);
command.Result = result.Select(r => _relationRenderer.Render(r, command.DictionaryId));
return(await base.HandleAsync(command, cancellationToken));
}
private async Task EnsureContactDoesNotExist(
CreateContactCommand command,
CancellationToken cancellationToken)
{
var query = new GetUserContactsQuery(command.UserId);
var list = await _queryProcessor.ExecuteAsync(query, cancellationToken);
if (list.Any(c => c.Phone == command.Phone))
{
throw new ValidationException(ErrorCodes.ContactExists);
}
}
public override async Task <GetTranslationByIdRequest> HandleAsync(GetTranslationByIdRequest command, CancellationToken cancellationToken = new CancellationToken())
{
var query = new GetTranslationByIdQuery
{
DictionaryId = command.DictionaryId, TranslationId = command.TranslationId
};
var result = await _queryProcessor.ExecuteAsync(query, cancellationToken);
command.Result = _translationRenderer.Render(result, command.DictionaryId);
return(await base.HandleAsync(command, cancellationToken));
}
public async Task <ActionResult <AuthDataViewModel> > Post([FromBody] LoginViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _queryProcessor.ExecuteAsync(new GetUserQuery(model.Email));
if (user == null)
{
return(BadRequest(new { loginError = "Invalid username password combination" }));
}
if (!user.IsOwnPassword(model.Password))
{
return(BadRequest(new { loginError = "Invalid username password combination" }));
}
return(new AuthDataViewModel(_jwtSecretKey, _jwtLifespan, user.Id));
}
public override async Task <ActivateUserCommand> HandleAsync(
ActivateUserCommand command,
CancellationToken cancellationToken = default)
{
var user = await _queryProcessor.ExecuteAsync(new GetUserByEmailQuery(command.Email), cancellationToken);
await _identityService.ActivateUserAsync(command.Email, cancellationToken);
await PublishEventAsync(user, cancellationToken);
return(await base.HandleAsync(command, cancellationToken));
}
public async Task <IActionResult> GetFile(int fileId, CancellationToken token = default(CancellationToken))
{
var query = new GetFileQuery(fileId, 200, 200);
var file = await _queryProcessor.ExecuteAsync(query, token);
if (file == null)
{
return(new NotFoundResult());
}
return(new FileContentResult(file.Contents, new MediaTypeHeaderValue(file.MimeType)));
}
public async Task <ActionResult> CompleteTask(CompleteTaskRequest request)
{
var task = await _queryProcessor.ExecuteAsync(new GetTaskQuery(request.TaskId));
if (task is null)
{
return(BadRequest($"Task with TaskId {request.TaskId} does not exist"));
}
await _commandProcessor.SendAsync(new CompleteTaskCommand(request.TaskId));
return(Ok());
}
private async Task EnsureNotExistsAsync(
EditUnitCommand command,
CancellationToken cancellationToken)
{
var units = await _queryProcessor.ExecuteAsync(new GetUserUnitsQuery(command.UserId), cancellationToken);
if (units.Any(
c => string.Equals(c.Name, command.NewName, StringComparison.InvariantCultureIgnoreCase) &&
c.Id != command.UnitId))
{
throw new ValidationException(ErrorCodes.UnitExists);
}
}
private async Task EnsureUnitDoesNotExistAsync(
CreateUnitCommand command,
CancellationToken cancellationToken = default)
{
var units = await _queryProcessor.ExecuteAsync(new GetUserUnitsQuery(command.UserId), cancellationToken);
if (units.Any(l => string.Equals(l.Name, command.Name, StringComparison.InvariantCultureIgnoreCase) &&
l.Grade == command.Grade &&
l.LessonId == command.LessonId))
{
throw new ValidationException(ErrorCodes.UnitExists);
}
}
private async Task EnsureClassroomDoesNotExistAsync(
CreateClassroomCommand command,
CancellationToken cancellationToken)
{
var query = new GetUserClassroomsQuery(command.UserId);
var list = await _queryProcessor.ExecuteAsync(query, cancellationToken);
if (list.Any(c => c.Grade == command.Grade &&
string.Equals(c.Name, command.Name, StringComparison.InvariantCultureIgnoreCase)))
{
throw new ValidationException(ErrorCodes.ClassroomExists);
}
}
private async Task EnsureNotExistsAsync(
EditExamCommand command,
CancellationToken cancellationToken)
{
var list = (await _queryProcessor.ExecuteAsync(
new GetUserExamsQuery(command.UserId), cancellationToken)).ToList();
if (list.Any(c => c.Name == command.NewName &&
c.Id != command.ExamId))
{
throw new ValidationException(ErrorCodes.ExamExists);
}
}
private async Task EnsureNotExistsAsync(
EditClassroomCommand command,
CancellationToken cancellationToken)
{
var classrooms = await _queryProcessor.ExecuteAsync(new GetUserClassroomsQuery(command.UserId), cancellationToken);
if (classrooms.Any(
c => c.Grade == command.NewGrade &&
string.Equals(c.Name, command.NewName, StringComparison.InvariantCultureIgnoreCase) &&
c.Id != command.ClassroomId))
{
throw new ValidationException(ErrorCodes.ClassroomExists);
}
}
private async Task EnsureNotExistsAsync(
EditStudentCommand command,
CancellationToken cancellationToken)
{
var students = await _queryProcessor.ExecuteAsync(
new GetUserStudentsQuery(command.UserId), cancellationToken);
if (students.Any(
s => s.StudentNumber == command.NewStudentNumber &&
s.Id != command.StudentId))
{
throw new ValidationException(ErrorCodes.StudentExists);
}
}
public override async Task <GetTranslationsForLanguageRequest> HandleAsync(GetTranslationsForLanguageRequest command, CancellationToken cancellationToken = new CancellationToken())
{
var query = new GetTranslationsByLanguageQuery
{
DictionaryId = command.DictionaryId,
WordId = command.WordId,
Language = command.Language
};
var result = await _queryProcessor.ExecuteAsync(query, cancellationToken);
command.Result = result.Select(t => _translationRenderer.Render(t, command.DictionaryId));
return(await base.HandleAsync(command, cancellationToken));
}
public async Task <ActionResult> SetTaskDueDate(SetTaskDueDateRequest request)
{
var task = await _queryProcessor.ExecuteAsync(new GetTaskQuery(request.TaskId));
if (task is null)
{
return(BadRequest($"Task with TaskId {request.TaskId} does not exist"));
}
await _commandProcessor.SendAsync(
new SetTaskDueDateCommand(request.TaskId, request.DueDate.Value));
return(Ok());
}
public override async Task <GetWordByIdRequest> HandleAsync(GetWordByIdRequest command, CancellationToken cancellationToken = new CancellationToken())
{
var model = await _queryProcessor.ExecuteAsync(new GetWordByIdQuery
{
DictionaryId = command.DictionaryId,
WordId = command.WordId
}, cancellationToken);
if (model == null)
{
throw new NotFoundException();
}
command.Result = _wordRenderer.Render(model);
return(await base.HandleAsync(command, cancellationToken));
}
private async Task PublishEventAsync(
string email,
string token,
CancellationToken cancellationToken)
{
var user = await _queryProcessor.ExecuteAsync(
new GetUserByEmailQuery(email),
cancellationToken);
var url = $"{_oAuthConfiguration.Authority}account/reset-password?token={token}&email={email}";
await _publishEndpoint.Publish(
new ResetPasswordTokenGenerated(url, email, user.FirstName, user.LastName),
cancellationToken);
}
private async Task EnsureStudentDoesNotExists(
CreateStudentCommand command,
CancellationToken cancellationToken)
{
var getUserStudentsQuery = new GetUserStudentsQuery(command.UserId);
var studentList = await _queryProcessor.ExecuteAsync(getUserStudentsQuery, cancellationToken);
var existingStudent = studentList.FirstOrDefault(x => x.StudentNumber == command.StudentNumber);
if (existingStudent != null)
{
var getUserClassroomsQuery = new GetUserClassroomsQuery(command.UserId);
var classroomList = await _queryProcessor.ExecuteAsync(getUserClassroomsQuery, cancellationToken);
var newStudentGrade = classroomList.First(c => c.Id == command.ClassroomId).Grade;
if ((Grade.CheckIfHighSchool(existingStudent.ClassroomGrade) &&
Grade.CheckIfHighSchool(newStudentGrade)) ||
(Grade.CheckIfSecondarySchool(existingStudent.ClassroomGrade) && Grade.CheckIfSecondarySchool(newStudentGrade)))
{
throw new ValidationException(ErrorCodes.StudentExists);
}
}
}
public override async Task <Command> HandleAsync(Command command, CancellationToken cancellationToken = new CancellationToken())
{
string teamName = command.TeamName;
if (command.RepositoryName.Contains('.'))
{
teamName = command.RepositoryName.GetSubstringBeforeString(".").ResolveRetailSuccessAsString();
}
var teamId = await _queryProcessor.ExecuteAsync(new GetTeamId.Query(command.Organization, teamName), cancellationToken);
await _client.Organization.Team.AddRepository((teamId.TeamId ?? default(int)), command.Organization, command.RepositoryName, new RepositoryPermissionRequest(Permission.Push));
return(await base.HandleAsync(command, cancellationToken));
}
public async Task <IActionResult> Get_Entity([FromRoute] string entityId, CancellationToken ctk = default)
{
var query = new Get_EntityByIdQuery.V1()
{
EntityId = entityId
};
var res = await _queryProcessor.ExecuteAsync(query, ctk);
if (res == null)
{
return(this.NotFound());
}
return(this.Ok(res));
}
public async Task <IActionResult> Create([FromBody] GetTokenRequest request)
{
var authenticateUserCommand = new AuthenticateUserCommand(
request.Username, request.Password);
await _commandProcessor.SendAsync(authenticateUserCommand);
if (!authenticateUserCommand.IsValidUsernameAndPassword)
{
return(BadRequest(new { Message = "Invalid username or password" }));
}
var user = await _queryProcessor.ExecuteAsync(new GetUserByUsernameQuery(request.Username));
return(new ObjectResult(GenerateToken(user)));
}
public override async Task <ExtendUserSubscriptionCommand> HandleAsync(
ExtendUserSubscriptionCommand command,
CancellationToken cancellationToken = default)
{
var user = await _queryProcessor.ExecuteAsync(new GetUserQuery(command.Email), cancellationToken);
await _identityClient.ExtendUserSubscriptionAsync(user.SubjectId, cancellationToken);
var newExpiryDate = DateTime.UtcNow > command.CurrentExpiryDateTimeUtc
? DateTime.UtcNow.AddYears(1)
: command.CurrentExpiryDateTimeUtc.AddYears(1);
await PublishEventAsync(user, newExpiryDate, cancellationToken);
return(await base.HandleAsync(command, cancellationToken));
}
public async Task <ActionResult <GetTaskResponse> > GetTask(string taskId)
{
var result = await _queryProcessor.ExecuteAsync(new GetTaskQuery(taskId));
if (result is null)
{
return(NotFound($"A task with TaskId {taskId} was not found."));
}
return(new GetTaskResponse(
result.TaskId,
result.Title,
result.Description,
result.DueDate,
result.CompletedDate));
}
public async Task <ActionResult <AddTaskResponse> > AddTask(AddTaskRequest request)
{
var task = await _queryProcessor.ExecuteAsync(new GetTaskQuery(request.TaskId));
if (task != null)
{
return(BadRequest($"Task with TaskId {request.TaskId} already exists"));
}
await _commandProcessor.SendAsync(new AddTaskCommand(request.TaskId, request.Title, request.Description,
request.DueDate));
var newUrl = $@"{Request.Host}/api/tasks/{request.TaskId}";
return(Created(newUrl,
new AddTaskResponse(request.TaskId, request.Title, request.Description, request.DueDate)));
}
public async Task <IActionResult> QueryGame([FromQuery] string userId)
{
var query = new GameQuery(userId);
GameView gameView;
try
{
gameView = await _queryProcessor.ExecuteAsync <GameView>(query);
}
catch (Exception ex)
{
_logger.LogError($"Error occurred in game query for user {query.UserId}: {ex.Message}.");
return(new StatusCodeResult(StatusCodes.Status500InternalServerError));
}
return(Ok(gameView));
}
public async Task CreateAndSetUpRepository(string repositoryName)
{
await _commandProcessor.SendAsync(new CreateRepository.Command(repositoryName, _gitHubClientOptions.OrganizationName));
var repositoryQuery = await _queryProcessor.ExecuteAsync(new GetRepositoryByName.Query(_gitHubClientOptions.OrganizationName, repositoryName));
var repositoryId = repositoryQuery.Repository.Id;
await _commandProcessor.SendAsync(new EnableRequiredReviews.Command(repositoryId));
await _commandProcessor.SendAsync(new EnableRequiredStatusChecks.Command(repositoryId));
await _commandProcessor.SendAsync(new CreateBranch.Command(repositoryId));
await _commandProcessor.SendAsync(new AddRepositoryToTeam.Command(repositoryName, _gitHubClientOptions.OrganizationName, _gitHubClientOptions.DefaultTeamName));
await _commandProcessor.SendAsync(new DisableForcePushAndDeletion.Command(repositoryId));
await _commandProcessor.SendAsync(new SetDefaultBranch.Command(repositoryQuery.Repository));
}
public override async Task <RemoveDictionaryDownloadRequest> HandleAsync(RemoveDictionaryDownloadRequest command, CancellationToken cancellationToken = new CancellationToken())
{
var localDictionaryQuery = new GetLocalDictionaryQuery
{
DictionaryId = command.DictionaryId
};
var localDictionary = await _queryProcessor.ExecuteAsync(localDictionaryQuery, cancellationToken);
if (localDictionary == null)
{
throw new NotFoundException();
}
await _commandProcessor.SendAsync(new RemoveLocalDictionaryCommand
{
DictionaryId = localDictionary.Id
}, cancellationToken : cancellationToken);
return(await base.HandleAsync(command, cancellationToken));
}
public override async Task <GetWordsStartingWithRequest> HandleAsync(GetWordsStartingWithRequest command, CancellationToken cancellationToken = new CancellationToken())
{
var words = await _queryProcessor.ExecuteAsync(new GetWordsStartingWithQuery
{
DictionaryId = command.DictionaryId,
StartingWith = command.StartingWith,
PageNumber = command.PageNumber,
PageSize = command.PageSize
}, cancellationToken);
command.Result = _wordPageRenderer.Render(new PageRendererArgs <WordModel>
{
Page = words,
RouteArguments = new PagedRouteArgs {
PageSize = command.PageSize, PageNumber = command.PageNumber
},
RouteName = "GetWordsListStartWith"
});
return(await base.HandleAsync(command, cancellationToken));
}
public override async Task <BookPageOcrRequest> HandleAsync(BookPageOcrRequest command, CancellationToken cancellationToken = new CancellationToken())
{
var bookPage = await _bookPageRepository.GetPageBySequenceNumber(command.LibraryId, command.BookId, command.SequenceNumber, cancellationToken);
if (bookPage != null && bookPage.ImageId.HasValue)
{
var image = await _queryProcessor.ExecuteAsync(new GetFileQuery(bookPage.ImageId.Value, 0, 0));
if (image != null)
{
var text = await _ocr.PerformOcr(image.Contents, command.ApiKey, cancellationToken);
bookPage.Text = text;
await _bookPageRepository.UpdatePage(command.LibraryId, bookPage.BookId, bookPage.SequenceNumber, text, bookPage.ImageId.Value, bookPage.Status, bookPage.ChapterId, cancellationToken);
return(await base.HandleAsync(command, cancellationToken));
}
}
throw new NotFoundException();
}
