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(); }