public async Task <IActionResult> GetTaskAsync([FromRoute] string taskId, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (!Guid.TryParse(taskId, out var modelToDoTaskId)) { var error = ServiceErrorResponses.ToDoTaskNotFound(taskId); return(this.NotFound(error)); } ToDoTask modelTask = null; try { modelTask = await this.tasks.GetAsync(modelToDoTaskId, cancellationToken); } catch (ToDoTaskNotFoundException) { var error = ServiceErrorResponses.ToDoTaskNotFound(taskId); return(NotFound(error)); } var clientTask = ToDoTaskConverter.Convert(modelTask); var userIdRequest = this.HttpContext.User.Claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier); if (userIdRequest.Value != clientTask.UserId) { var error = ServiceErrorResponses.AccessDenied(); return(StatusCode(StatusCodes.Status403Forbidden, error)); } return(this.Ok(clientTask)); }
public async Task <IActionResult> CreateAsync([FromBody] Client.Maraphone.Task.ContentBuildInfo contentBuildInfo, CancellationToken cancellationToken) { if (contentBuildInfo == null) { var error = ServiceErrorResponses.BodyIsMissing("ContentBuildInfo"); return(this.BadRequest(error)); } var contentType = HttpContext.Request.Headers["Skima-Data-Type"].FirstOrDefault(); if (contentType == null) { return(this.BadRequest("Content not specified")); } var contentCreationInfo = new ContentCreationInfo(contentType, contentBuildInfo.Data); var document = await contentRepository.CreateAsync(contentCreationInfo, cancellationToken); var result = new ContentResult { Id = document.Id }; return(CreatedAtRoute( "GetContent", new { id = result.Id }, result)); }
public async Task <IActionResult> CreateTaskAsync([FromBody] Client.Models.ToDoTasks.ToDoTaskBuildInfo buildInfo, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (buildInfo == null) { var error = ServiceErrorResponses.BodyIsMissing("ToDoTasksBuildInfo"); return(this.BadRequest(error)); } var userIdClame = this.HttpContext.User.Claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier); var modelCreationInfo = ToDoTaskBuildInfoConverter.Convert(userIdClame.Value, buildInfo); var modelTaskInfo = await this.tasks.CreateAsync(modelCreationInfo, cancellationToken); var clientTaskInfo = ToDoTaskInfoConverter.Convert(modelTaskInfo); var routeParams = new Dictionary <string, object> { { "taskId", clientTaskInfo.Id } }; return(this.CreatedAtRoute("GetTaskRouteV2", routeParams, clientTaskInfo)); }
public async Task <IActionResult> GetNoteAsync( [FromRoute] string noteId, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (!this.TryGetSessionState(this.HttpContext.Request.Cookies, out var state)) { return(this.Unauthorized()); } if (!Guid.TryParse(noteId, out var noteIdGuid)) { var error = ServiceErrorResponses.NoteNotFound(noteId); return(this.NotFound(error)); } Models.Notes.Note modelNote = null; try { modelNote = await this.repository.GetAsync(noteIdGuid, cancellationToken).ConfigureAwait(false); } catch (Models.Notes.NoteNotFoundExcepction) { var error = ServiceErrorResponses.NoteNotFound(noteId); return(this.NotFound(error)); } if (!state.UserId.Equals(modelNote.UserId)) { return(this.Forbid()); } var clientNote = NoteConverter.Convert(modelNote); return(this.Ok(clientNote)); }
public async Task <IActionResult> RegisterUser([FromBody] Client.Models.Users.UserRegistrationInfo registrationInfo, CancellationToken cancellationToken) { if (registrationInfo == null) { var error = ServiceErrorResponses.BodyIsMissing("RegistrationInfo"); return(BadRequest(error)); } if (registrationInfo.Login == null || registrationInfo.Password == null) { var error = ServiceErrorResponses.NotEnoughUserData(); return(BadRequest(error)); } var creationInfo = new UserCreationInfo(registrationInfo.Login, Auth.AuthHash.GetHashPassword(registrationInfo.Password)); User user = null; try { user = await users.CreateAsync(creationInfo, cancellationToken); } catch (UserDuplicationException) { var error = ServiceErrorResponses.UserNameAlreadyExists(registrationInfo.Login); return(BadRequest(error)); } var clientUser = UserConverter.Convert(user); return(Ok(clientUser)); }
public async Task <IActionResult> CreateUserAsync([FromBody] Client.UserCreationInfo creationInfo, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (creationInfo == null) { var error = ServiceErrorResponses.BodyIsMissing("UserCreationInfo"); return(BadRequest(error)); } var hashPassword = PasswordEncoder.Encode(creationInfo.Password); var modelCreationInfo = new UserCreationInfo(creationInfo.Login, hashPassword); User modelUser = null; try { modelUser = await repository.CreateAsync(modelCreationInfo, cancellationToken) .ConfigureAwait(false); } catch (UserDuplicationException) { var error = ServiceErrorResponses.UserDuplication(modelCreationInfo.Login); return(BadRequest(error)); } var clientUser = UserConverter.Convert(modelUser); return(Ok(clientUser)); }
public async Task <IActionResult> GetTodoItemAsync([FromRoute] string todoId, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (!Guid.TryParse(todoId, out var modelTodoItemId)) { var error = ServiceErrorResponses.TodoNotFound(todoId); return(NotFound(error)); } if (!HttpContext.Items.TryGetValue("userId", out var userId) || !Guid.TryParse(userId.ToString(), out var userGuid)) { var error = ServiceErrorResponses.UnAuthorized(); return(BadRequest(error)); } Model.TodoItem modelTodoItem = null; try { modelTodoItem = await repository.GetAsync(modelTodoItemId, userGuid, cancellationToken).ConfigureAwait(false); } catch (Model.TodoNotFoundException) { var error = ServiceErrorResponses.TodoNotFound(todoId); return(NotFound(error)); } var clientTodoItem = ModelsConverters.TodoItems.TodoItemConverter.Convert(modelTodoItem); return(Ok(clientTodoItem)); }
public async Task <IActionResult> CreateAsync([FromBody] Client.Maraphone.MaraphoneBuildInfo buildInfo, CancellationToken cancellationToken) { if (buildInfo == null) { var error = ServiceErrorResponses.BodyIsMissing("MaraphoneBuildInfo"); return(this.BadRequest(error)); } var userId = User.FindFirstValue("userId"); if (userId == null) { var error = ServiceErrorResponses.InvalidClaims("userId"); return(this.BadRequest(error)); } var maraphoneCreationInfo = new MaraphoneCreationInfo(buildInfo, userId); var modelMaraphone = await maraphoneRepository.CreateAsync(maraphoneCreationInfo, cancellationToken); var clientMaraphone = MaraphoneConverter.Convert(modelMaraphone); return(CreatedAtRoute( "GetMaraphone", new { id = clientMaraphone.Id }, clientMaraphone)); }
public async Task <IActionResult> CreateItemsAsync([FromBody] Client.TodoItems.TodoItemBuildInfo buildInfo, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (buildInfo == null) { var error = ServiceErrorResponses.BodyIsMissing("TodoItemBuildInfo"); return(this.BadRequest(error)); } var name = User.Identity.Name; var usser = this.usersRepository.Get(name).Id; var creationInfo = TodoItemBuildInfoConverter.Convert(usser.ToString(), buildInfo); var modelItemInfo = await this.itemsRepository.CreateAsync(creationInfo, cancellationToken).ConfigureAwait(false); var clientItemInfo = TodoItemInfoConverter.Convert(modelItemInfo); var routeParams = new Dictionary <string, object> { { "itemId", clientItemInfo.Id } }; return(this.CreatedAtRoute("GetItemRoute", routeParams, clientItemInfo)); }
public async Task <IActionResult> PatchNoteAsync([FromRoute] string noteId, [FromBody] Client.Notes.NotePatchInfo patchInfo, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (patchInfo == null) { var error = ServiceErrorResponses.BodyIsMissing("NotePatchInfo"); return(this.BadRequest(error)); } if (!Guid.TryParse(noteId, out var noteIdGuid)) { var error = ServiceErrorResponses.NoteNotFound(noteId); return(this.NotFound(error)); } var modelPathInfo = NotePathcInfoConverter.Convert(noteIdGuid, patchInfo); Model.Notes.Note modelNote = null; try { modelNote = await this.repository.PatchAsync(modelPathInfo, cancellationToken).ConfigureAwait(false); } catch (Model.Notes.NoteNotFoundExcepction) { var error = ServiceErrorResponses.NoteNotFound(noteId); return(this.NotFound(error)); } var clientNote = NoteConverter.Convert(modelNote); return(this.Ok(clientNote)); }
public async Task <IActionResult> CreateNoteAsync( [FromBody] Client.Notes.NoteBuildInfo clientBuildInfo, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (!this.TryGetSessionState(this.HttpContext.Request.Cookies, out var state)) { return(this.Unauthorized()); } if (!this.ModelState.IsValid) { var error = ServiceErrorResponses.BodyIsMissing(nameof(Client.Notes.NoteBuildInfo)); return(this.BadRequest(error)); } var modelBuildInfo = NoteBuildInfoConverter.Convert(state.UserId.ToString(), clientBuildInfo); var modelNoteInfo = await this.repository.CreateAsync(modelBuildInfo, cancellationToken).ConfigureAwait(false); var clientNoteInfo = NoteInfoConverter.Convert(modelNoteInfo); var routeParams = new Dictionary <string, object> { { "noteId", clientNoteInfo.Id } }; return(this.CreatedAtRoute("GetNoteRoute", routeParams, clientNoteInfo)); }
public async Task <IActionResult> GetToDoAsync(string userId, string todoId) { var UserIdfromTokken = HttpContext.User.FindFirst(p => p.Type == "sub").Value; if (UserIdfromTokken == null || userId != UserIdfromTokken) { var error = ServiceErrorResponses.AuthIsNotConfirmed("Unauthorized request"); } var todoServ = new ToDoService(UserIdfromTokken); if (!int.TryParse(todoId, out var ToDoIdCheck)) { var error = ServiceErrorResponses.ToDoNotFound(todoId); return(this.NotFound(error)); } var todoIdGet = todoServ.Get(ToDoIdCheck); if (todoIdGet == null) { var error = ServiceErrorResponses.ToDoNotFound(todoId); return(this.NotFound(error)); } return(this.Ok(todoIdGet)); }
public async Task <IActionResult> UpdateAsync([FromBody] Client.Users.UserPatchInfo patchInfo, CancellationToken cancellationToken) { if (patchInfo == null) { var error = ServiceErrorResponses.BodyIsMissing("UserPatchInfo"); return(this.BadRequest(error)); } var userId = User.FindFirstValue("userId"); if (userId == null) { var error = ServiceErrorResponses.InvalidClaims("userId"); return(this.BadRequest(error)); } User modelUser; try { modelUser = await userRepository.PatchAsync(patchInfo, userId, cancellationToken); } catch (UserNotFoundException e) { var error = ServiceErrorResponses.NoSuchObject("User", e.Message); return(this.NotFound(error)); } var clientUserInfo = UserConverter.ConvertToUserInfo(modelUser); return(Ok(clientUserInfo)); }
public async Task <IActionResult> DeleteNoteAsync( [FromRoute] string noteId, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (!this.TryGetSessionState(this.HttpContext.Request.Cookies, out var state)) { return(this.Unauthorized()); } if (!Guid.TryParse(noteId, out var noteIdGuid)) { var error = ServiceErrorResponses.NoteNotFound(noteId); return(this.NotFound(error)); } if (!this.IsNoteBelongsToUserAsync(state, noteIdGuid, cancellationToken).Result) { return(this.Forbid()); } try { await this.repository.RemoveAsync(noteIdGuid, cancellationToken).ConfigureAwait(false); } catch (Models.Notes.NoteNotFoundExcepction) { var error = ServiceErrorResponses.NoteNotFound(noteId); return(this.NotFound(error)); } return(this.NoContent()); }
public async Task <IActionResult> GetTodoAsync([FromRoute] string recordId, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); Todo record; var nameIdentifier = this.HttpContext.User.Claims .FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier); var user = await _userRepository.GetAsync(nameIdentifier.Value, cancellationToken).ConfigureAwait(false); if (!Guid.TryParse(recordId, out var modelTodoId)) { var error = ServiceErrorResponses.TodoNotFound(recordId); return(this.NotFound(error)); } if (!await IsSameUser(modelTodoId, cancellationToken)) { var error = ServiceErrorResponses.TodoNotFound(recordId); return(NotFound(error)); } try { record = await _todoService.GetAsync(modelTodoId, cancellationToken).ConfigureAwait(false); } catch (RecordNotFoundException e) { var error = ServiceErrorResponses.TodoNotFound(recordId); return(NotFound(error)); } var clientRecord = TodoConverter.Convert(record); return(this.Ok(clientRecord)); }
public IActionResult GetItem([FromRoute] string itemId, CancellationToken cancelltionToken) { cancelltionToken.ThrowIfCancellationRequested(); if (!Guid.TryParse(itemId, out var modelItemId)) { var error = ServiceErrorResponses.ItemNotFound(itemId); return(this.NotFound(error)); } Model.TodoItems.TodoItem modelItem = null; var userid = this.usersRepository.Get(User.Identity.Name).Id; try { modelItem = this.itemsRepository.GetAsync(modelItemId, cancelltionToken, userid); } catch (Model.TodoItems.TodoItemNotFoundExcepction) { var error = ServiceErrorResponses.ItemNotFound(itemId); return(this.NotFound(error)); } var clientItem = TodoItemConverter.Convert(modelItem); return(this.Ok(clientItem)); }
public async Task <IActionResult> CreateNoteAsync([FromBody] ClientModels.Todos.TodoBuildInfo buildInfo, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (buildInfo == null) { var error = ServiceErrorResponses.BodyIsMissing("buildInfo"); return(this.BadRequest(error)); } var nameIdentifier = this.HttpContext.User.Claims .FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier); var user = await _userRepository.GetAsync(nameIdentifier.Value, cancellationToken).ConfigureAwait(false); var creationInfo = TodoBuildInfoConverter.Convert(user.Id.ToString(), buildInfo); var modelTodoInfo = await _todoService.CreateAsync(creationInfo, cancellationToken).ConfigureAwait(false); var clientTodoInfo = TodoInfoConverter.Convert(modelTodoInfo); var routeParams = new Dictionary <string, object> { { "recordId", clientTodoInfo.Id } }; return(CreatedAtRoute("GetTodoRoute", routeParams, clientTodoInfo)); }
public async Task <IActionResult> DeleteNoteAsync([FromRoute] string recordId, CancellationToken cancellationToken) { if (!Guid.TryParse(recordId, out var recordIdGuid)) { var error = ServiceErrorResponses.TodoNotFound(recordId); return(this.NotFound(error)); } if (!await IsSameUser(recordIdGuid, cancellationToken)) { var error = ServiceErrorResponses.TodoNotFound(recordId); return(NotFound(error)); } try { await this._todoService.RemoveAsync(recordIdGuid, cancellationToken).ConfigureAwait(false); } catch (RecordNotFoundException) { var error = ServiceErrorResponses.TodoNotFound(recordId); return(this.NotFound(error)); } return(this.NoContent()); }
public async Task <IActionResult> GetNoteAsync([FromRoute] string noteId, CancellationToken cancelltionToken) { cancelltionToken.ThrowIfCancellationRequested(); if (!Guid.TryParse(noteId, out var modelNoteId)) { var error = ServiceErrorResponses.NoteNotFound(noteId); return(this.NotFound(error)); } Model.Notes.Note modelNote = null; try { modelNote = await this.repository.GetAsync(modelNoteId, cancelltionToken).ConfigureAwait(false); } catch (Model.Notes.NoteNotFoundExcepction) { var error = ServiceErrorResponses.NoteNotFound(noteId); return(this.NotFound(error)); } var clientNote = NoteConverter.Convert(modelNote); return(this.Ok(clientNote)); }
public async Task <IActionResult> GetUserByLoginAsync([FromRoute] string userLogin, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (userLogin == null) { var error = ServiceErrorResponses.BodyIsMissing(userLogin); return(BadRequest(error)); } User modelUser = null; try { modelUser = await repository.GetAsync(userLogin, cancellationToken).ConfigureAwait(false); } catch (UserNotFoundException) { var error = ServiceErrorResponses.UserNotFound(userLogin); return(NotFound(error)); } var clientUser = UserConverter.Convert(modelUser); return(Ok(clientUser)); }
public async Task <IActionResult> DeleteTodoItemAsync([FromRoute] string todoId, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (!Guid.TryParse(todoId, out var todoGuid)) { var error = ServiceErrorResponses.TodoNotFound(todoId); return(NotFound(error)); } if (!HttpContext.Items.TryGetValue("userId", out var userId) || !Guid.TryParse(userId.ToString(), out var userGuid)) { var error = ServiceErrorResponses.UnAuthorized(); return(BadRequest(error)); } try { await repository.RemoveAsync(todoGuid, userGuid, cancellationToken).ConfigureAwait(false); } catch (Model.TodoNotFoundException) { var error = ServiceErrorResponses.TodoNotFound(todoId); return(NotFound(error)); } return(NoContent()); }
public async Task <IActionResult> PatchNoteAsync([FromRoute] string itemId, [FromBody] Client.TodoItems.TodoItemPatchInfo patchInfo, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (patchInfo == null) { var error = ServiceErrorResponses.BodyIsMissing("ItemPatchInfo"); return(this.BadRequest(error)); } if (!Guid.TryParse(itemId, out var ItemIdGuid)) { var error = ServiceErrorResponses.ItemNotFound(itemId); return(this.NotFound(error)); } var modelPathInfo = TodoItemPathcInfoConverter.Convert(ItemIdGuid, patchInfo); Model.TodoItems.TodoItem modelItem = null; var userid = this.usersRepository.Get(User.Identity.Name).Id; try { modelItem = await this.itemsRepository.PatchAsync(modelPathInfo, cancellationToken, userid).ConfigureAwait(false); } catch (Model.TodoItems.TodoItemNotFoundExcepction) { var error = ServiceErrorResponses.ItemNotFound(itemId); return(this.NotFound(error)); } var clientItem = TodoItemConverter.Convert(modelItem); return(this.Ok(clientItem)); }
public async Task <IActionResult> CreateTodoItemAsync([FromBody] Client.TodoCreationInfo creationInfo, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (creationInfo == null) { var error = ServiceErrorResponses.BodyIsMissing("TodoCreationInfo"); return(BadRequest(error)); } if (!HttpContext.Items.TryGetValue("userId", out var userId) || !Guid.TryParse(userId.ToString(), out var userGuid)) { var error = ServiceErrorResponses.UnAuthorized(); return(BadRequest(error)); } var modelCreationInfo = Converter.TodoCreationInfoConverter.Convert(userGuid, creationInfo); var modelTodoItem = await repository.CreateAsync(modelCreationInfo, cancellationToken).ConfigureAwait(false); var clientTodoItem = Converter.TodoItemConverter.Convert(modelTodoItem); var routeParams = new Dictionary <string, object> { { "todoId", clientTodoItem.Id } }; return(CreatedAtRoute("GetTodoItem", routeParams, clientTodoItem)); }
public async Task <IActionResult> Register([FromBody] Client.Users.UserRegistrationInfo registrationInfo, CancellationToken cancellationToken) { if (registrationInfo == null) { var error = ServiceErrorResponses.BodyIsMissing("UserRegistrationInfo"); return(this.BadRequest(error)); } User result; var creationInfo = new UserCreationInfo(registrationInfo.Login, Authenticator.HashPassword(registrationInfo.Password), registrationInfo.FirstName, registrationInfo.LastName, registrationInfo.Email, registrationInfo.Phone); try { result = await userRepository.CreateAsync(creationInfo, cancellationToken); } catch (UserDuplicationException) { var error = ServiceErrorResponses.ConflictLogin(creationInfo?.Login); return(this.Conflict(error)); } var clientUser = UserConverter.Convert(result); return(this.Ok(clientUser)); }
public async Task <IActionResult> CreateAsync([FromBody] Client.Entry.EntryBuildInfo entryBuildInfo, CancellationToken cancellationToken) { if (entryBuildInfo == null) { var error = ServiceErrorResponses.BodyIsMissing("Entry"); return(this.BadRequest(error)); } var userId = User.FindFirstValue("userId"); if (userId == null) { var error = ServiceErrorResponses.InvalidClaims("userId"); return(this.BadRequest(error)); } var entryCreationInfo = new EntryCreationInfo(userId, entryBuildInfo.ActivityId); Entry modelEntry; try { modelEntry = await entryRepository.CreateAsync(entryCreationInfo, cancellationToken); } catch (EntryDuplicationException e) { return(BadRequest(e.Message)); } var clientEntry = EntryConverter.Convert(modelEntry); return(CreatedAtRoute( "GetEntry", new { id = clientEntry.Id }, clientEntry)); }
public async Task <IActionResult> PutTodoItem(Guid?id, [FromBody] View.ToDoItemPatchInfo item) { if (id == null) { throw new ArgumentNullException(nameof(id)); } var modelPatchInfo = Converter.ToDoItemPatchInfoConverter.Convert(item); var modelItem = new Model.TodoItem { Id = id.Value, Name = modelPatchInfo.Name, IsComplete = modelPatchInfo.IsComplete }; if (id != modelItem.Id) { var error = ServiceErrorResponses.ItemNotFound(id.ToString()); return(this.NotFound(error)); } context.Entry(modelItem).State = EntityState.Modified; await context.SaveChangesAsync(); return(NoContent()); }
public async Task <IActionResult> GenerateToken([FromBody] Client.Models.Users.UserRegistrationInfo userInfo, [FromServices] IJwtSigningEncodingKey signingEncodingKey, CancellationToken cancellationToken) { if (userInfo == null) { var error = ServiceErrorResponses.BodyIsMissing("UserInfo"); return(BadRequest(error)); } if (userInfo.Login == null || userInfo.Password == null) { var error = ServiceErrorResponses.NotEnoughUserData(); return(BadRequest(error)); } User user; try { user = await users.GetAsync(userInfo.Login, cancellationToken); } catch (UserNotFoundException) { var error = ServiceErrorResponses.UserNotFound(userInfo.Login); return(BadRequest(error)); } if (user.PasswordHash != Auth.AuthHash.GetHashPassword(userInfo.Password)) { var error = ServiceErrorResponses.IncorrectPassword(); return(BadRequest(error)); } var clientUser = UserConverter.Convert(user); var claims = new Claim[] { new Claim(ClaimTypes.Name, clientUser.Login), new Claim(ClaimTypes.NameIdentifier, clientUser.Id), }; var token = new JwtSecurityToken( //issuer: "ToDoTasksApp", //audience: "ToDoTasksClient", claims: claims, expires: DateTime.Now.AddMinutes(AuthOptions.LIFETIME), signingCredentials: new SigningCredentials(signingEncodingKey.GetKey(), signingEncodingKey.SigningAlgorithm) ); var encodedJwt = new JwtSecurityTokenHandler().WriteToken(token); return(Ok(new AuthTokenAnswer { Login = userInfo.Login, AccessToken = encodedJwt })); }
public async Task <IActionResult> RemoveTaskAsync([FromRoute] string taskId, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (!Guid.TryParse(taskId, out var modelToDoTaskId)) { var error = ServiceErrorResponses.ToDoTaskNotFound(taskId); return(this.NotFound(error)); } var userLoginRequest = this.HttpContext.User.Claims.FirstOrDefault(x => x.Type == ClaimTypes.Name); User user = null; try { user = await users.GetAsync(userLoginRequest.Value, cancellationToken); } catch { var error = ServiceErrorResponses.UserNotFound(userLoginRequest.Value); return(BadRequest(error)); } ToDoTask modelTask = null; try { modelTask = await this.tasks.GetAsync(modelToDoTaskId, cancellationToken); } catch (ToDoTaskNotFoundException) { var error = ServiceErrorResponses.ToDoTaskNotFound(taskId); return(NotFound(error)); } if (user.Id != modelTask.UserId) { var error = ServiceErrorResponses.AccessDenied(); return(StatusCode(StatusCodes.Status403Forbidden, error)); } try { await tasks.RemoveAsync(modelToDoTaskId, cancellationToken); } catch (ToDoTaskNotFoundException) { var error = ServiceErrorResponses.ToDoTaskNotFound(taskId); return(NotFound(error)); } return(NoContent()); }
public async Task <IActionResult> PatchToDoAsync([FromRoute] string userId, string todoId, [FromBody] ToDoUpdateInfo updInfo) { var UserIdfromTokken = HttpContext.User.FindFirst(p => p.Type == "sub").Value; if (UserIdfromTokken == null || userId != UserIdfromTokken) { var error = ServiceErrorResponses.AuthIsNotConfirmed("Unauthorized request"); } var todoServ = new ToDoService(UserIdfromTokken); if (!int.TryParse(todoId, out var ToDoIdCheck)) { var error = ServiceErrorResponses.ToDoNotFound(todoId); return(this.NotFound(error)); } var todoIdPatch = todoServ.Get(ToDoIdCheck); if (todoIdPatch == null) { var error = ServiceErrorResponses.ToDoNotFound(todoId); return(this.NotFound(error)); } var updated = false; if (updInfo.Text != null) { todoIdPatch.Text = updInfo.Text; updated = true; } if (updInfo.IsDone != null) { todoIdPatch.IsDone = updInfo.IsDone.Value; updated = true; } if (!updated) { var error = ServiceErrorResponses.BodyIsMissingOrUncorrect(updInfo.ToString()); return(this.BadRequest(error)); } todoIdPatch.LastUpdatedAt = DateTime.UtcNow; todoServ.Update(ToDoIdCheck, todoIdPatch); var clientToDo = ToDoConverter.Convert(todoIdPatch); return(this.Ok(clientToDo)); }
public async Task <IActionResult> DeleteAsync() { var userId = User.FindFirstValue("userId"); if (userId == null) { var error = ServiceErrorResponses.InvalidClaims("userId"); return(this.BadRequest(error)); } await userRepository.RemoveAsync(userId); return(NoContent()); }