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