public async Task <IActionResult> UpdateNote(int NoteId, UpdateNoteRequest updateNotesDetails)
{
try
{
var user = HttpContext.User;
bool status = false;
string message;
if (user.HasClaim(c => c.Type == _tokenType))
{
if (user.Claims.FirstOrDefault(c => c.Type == _tokenType).Value == _login &&
user.Claims.FirstOrDefault(c => c.Type == _userType).Value == _regularUser)
{
int UserId = Convert.ToInt32(user.Claims.FirstOrDefault(c => c.Type == _userId).Value);
NoteResponseModel data = await _notesBusiness.UpdateNotes(NoteId, UserId, updateNotesDetails);
if (data != null)
{
status = true;
message = "Note Updated Successfull";
return(Ok(new { status, message, data }));
}
message = "Note Cannot be Updated.";
return(Ok(new { status, message }));
}
}
message = "Invalid Token.";
return(BadRequest(new { status, message }));
}
catch (Exception e)
{
return(BadRequest(new { e.Message }));
}
}
public async Task UpdateNoteAsync()
{
Mock <Grafeas.GrafeasClient> mockGrpcClient = new Mock <Grafeas.GrafeasClient>(MockBehavior.Strict);
UpdateNoteRequest expectedRequest = new UpdateNoteRequest
{
NoteName = new NoteName("[PROJECT]", "[NOTE]"),
Note = new Note(),
UpdateMask = new FieldMask(),
};
Note expectedResponse = new Note
{
NoteName = new NoteName("[PROJECT]", "[NOTE]"),
ShortDescription = "shortDescription-235369287",
LongDescription = "longDescription-1747792199",
};
mockGrpcClient.Setup(x => x.UpdateNoteAsync(expectedRequest, It.IsAny <CallOptions>()))
.Returns(new Grpc.Core.AsyncUnaryCall <Note>(Task.FromResult(expectedResponse), null, null, null, null));
GrafeasClient client = new GrafeasClientImpl(mockGrpcClient.Object, null);
NoteName name = new NoteName("[PROJECT]", "[NOTE]");
Note note = new Note();
FieldMask updateMask = new FieldMask();
Note response = await client.UpdateNoteAsync(name, note, updateMask);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public async Task <IHttpActionResult> Update(Guid id, [FromBody] UpdateNoteRequest request)
{
request.Id = id;
await _noteService.Update(request);
return(Ok());
}
public IActionResult UpdateNotes(int noteID, UpdateNoteRequest updateNoteRequest)
{
try
{
var idClaim = HttpContext.User.Claims.FirstOrDefault(id => id.Type.Equals("id", StringComparison.InvariantCultureIgnoreCase));
int userId = Convert.ToInt32(idClaim.Value);
UserNoteResponseData userUpdateData = _userNoteBusiness.UpdateNote(userId, noteID, updateNoteRequest);
bool success = false;
string message;
if (userUpdateData == null)
{
message = "Try again";
return(Ok(new { success, message }));
}
else
{
success = true;
message = "Notes Updated Successfully";
return(Ok(new { success, message, userUpdateData }));
}
}
catch (Exception ex)
{
return(BadRequest(new { ex.Message }));
}
}
public UserNoteResponseData UpdateNote(int userID, int noteID, UpdateNoteRequest updateNoteRequest)
{
try
{
UserNoteResponseData userNoteResponseData = null;
var userData = _context.UserNotes.FirstOrDefault(user => user.UserId == userID && user.NotesId == noteID);
userData.Title = updateNoteRequest.Title;
userData.Description = updateNoteRequest.Description;
_context.SaveChanges();
userNoteResponseData = new UserNoteResponseData()
{
NoteId = userData.NotesId,
Title = userData.Title,
Description = userData.Description,
Color = userData.Color,
Image = userData.Image,
Pin = userData.Pin,
Archived = userData.Archived,
Trash = userData.Trash,
Reminder = userData.Reminder
};
return(userNoteResponseData);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>Handles a request</summary>
/// <param name="request">The request</param>
/// <param name="cancellationToken">Cancellation token</param>
/// <returns>Response from the request</returns>
public async Task <Result <NoteDto> > Handle(UpdateNoteRequest request, CancellationToken cancellationToken)
{
var note = _mapper.Map <INote>(request.Note);
var result = await _noteRepository.UpdateAsync(note);
return(result.ToResult(_ => _mapper.Map <NoteDto>(result.ValueOrDefault)));
}
public async Task <ActionResult> Post([FromRoute] int id, [FromBody] UpdateNoteRequest model, CancellationToken cancellationToken)
{
var command = new TemperatureNoteUpdateCommand {
Id = id, Note = model.Value
};
await mediator.Send(command, cancellationToken);
return(Ok());
}
public async Task <IActionResult> UpdateNote([FromBody] UpdateNoteRequest request)
{
var response = await _noteService.UpdateNote(request);
if (!response)
{
return(BadRequest());
}
return(Ok());
}
internal static NoteEntity ToEntity(this UpdateNoteRequest request)
{
return(request == null ? null : new NoteEntity
{
UID = request.UID,
Name = request.Name,
Description = request.Description,
Note = request.Note,
});
}
//Update Note
public void Update(UpdateNoteRequest model, int createdById)
{
string procName = "[dbo].[Notes_Update]";
_data.ExecuteNonQuery(procName, delegate(SqlParameterCollection col)
{
MapNoteAddRequest(model, createdById, col);
col.AddWithValue("@Id", model.Id);
}, returnParameters: null);
}
public async Task <BaseResponse> UpdateAsync(UpdateNoteRequest request)
{
BaseResponse _Response = new BaseResponse();
if (request.UID == Guid.Empty || !await __NoteRepository.UpdateAsync(request.ToEntity()))
{
_Response.Success = false;
_Response.ErrorMessage = $"{GlobalConstants.ERROR_ACTION_PREFIX} retrieve {ENTITY_NAME}.";
}
return(_Response);
}
public IHttpActionResult UpdateNote([FromBody] UpdateNoteRequest updateNoteRequest)
{
try
{
Database.UpdateNote(updateNoteRequest.noteID, updateNoteRequest.noteText);
}
catch (Exception)
{
return(BadRequest());
}
return(Ok());
}
public async Task Update(UpdateNoteRequest request)
{
var note = GetOrThrowIfNotFound(request.Id);
note.FirstName = request.FirstName;
note.LastName = request.LastName;
note.Phone = request.Phone;
note.AdditionalInfo = request.AdditionalInfo;
request.Email = request.Email;
_noteRepository.Update(note);
await _noteRepository.SaveChangesAsync();
}
/// <summary>
/// Update an existing public/private note.
///
/// c.f. https://developers.freshdesk.com/api/#update_conversation
/// </summary>
///
/// <param name="conversationEntryId">
/// The unique identifier for the note
/// </param>
///
/// <param name="request">
/// Defines the fields to update on the note.
/// </param>
///
/// <param name="cancellationToken"></param>
///
/// <returns>The updated note</returns>
public async Task <ConversationEntry> UpdateNoteAsync(
long conversationEntryId,
UpdateNoteRequest request,
CancellationToken cancellationToken = default)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request), "Request must not be null");
}
return(await _client
.ApiOperationAsync <ConversationEntry>(HttpMethod.Put, $"/api/v2/conversations/{conversationEntryId}", request, cancellationToken)
.ConfigureAwait(false));
}
/// <summary>
/// Update the Note Data
/// </summary>
/// <param name="notesDetails">Note Data</param>
/// <returns>return Updated Notes, if Successfull, or else null</returns>
public async Task <NoteResponseModel> UpdateNotes(int noteId, int userId, UpdateNoteRequest updateNotesDetails)
{
try
{
if (noteId <= 0 || userId <= 0 || updateNotesDetails == null)
{
return(null);
}
else
{
return(await _notesRepository.UpdateNotes(noteId, userId, updateNotesDetails));
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public ActionResult <ItemResponse <int> > Update(UpdateNoteRequest model)
{
int iCode = 200;
BaseResponse response = null;
try
{
int userId = _authService.GetCurrentUserId();
_service.Update(model, userId);
response = new SuccessResponse();
}
catch (Exception ex)
{
iCode = 500;
base.Logger.LogError(ex.ToString());
response = new ErrorResponse($"Server Error: {ex.Message}");
}
return(StatusCode(iCode, response));
}
public UpdateNoteResponse UpdateNote(UpdateNoteRequest request)
{
Logger.Current.Verbose("Request for updating note");
Logger.Current.Informational("NoteId :" + request.NoteViewModel.NoteId);
Note note = Mapper.Map <NoteViewModel, Note>(request.NoteViewModel);
isNoteValid(note);
noteRepository.Update(note);
unitOfWork.Commit();
foreach (Tag tag in note.Tags.Where(t => t.Id == 0))
{
if (tag.Id == 0)
{
Tag savedTag = tagRepository.FindBy(tag.TagName, request.AccountId);
indexingService.IndexTag(savedTag);
accountService.ScheduleAnalyticsRefresh(savedTag.Id, (byte)IndexType.Tags);
}
}
if (request.NoteViewModel.Contacts != null && request.NoteViewModel.Contacts.Count() > 0)
{
var noteContactIds = request.NoteViewModel.Contacts.Select(c => c.Id).ToList();
List <LastTouchedDetails> details = new List <LastTouchedDetails>();
foreach (var id in noteContactIds)
{
LastTouchedDetails detail = new LastTouchedDetails();
detail.ContactID = id;
detail.LastTouchedDate = DateTime.UtcNow;
details.Add(detail);
}
updateLastTouchedInformation(details);
contactService.ContactIndexing(new ContactIndexingRequest()
{
ContactIds = noteContactIds, Ids = noteContactIds.ToLookup(o => o, o => { return(true); })
});
}
// this.addToMessageQueue(note, request.AccountId);
this.addToTopic(note, request.AccountId);
return(new UpdateNoteResponse());
}
public void UpdateNote2()
{
Mock <Grafeas.GrafeasClient> mockGrpcClient = new Mock <Grafeas.GrafeasClient>(MockBehavior.Strict);
UpdateNoteRequest request = new UpdateNoteRequest
{
NoteName = new NoteName("[PROJECT]", "[NOTE]"),
Note = new Note(),
};
Note expectedResponse = new Note
{
NoteName = new NoteName("[PROJECT]", "[NOTE]"),
ShortDescription = "shortDescription-235369287",
LongDescription = "longDescription-1747792199",
};
mockGrpcClient.Setup(x => x.UpdateNote(request, It.IsAny <CallOptions>()))
.Returns(expectedResponse);
GrafeasClient client = new GrafeasClientImpl(mockGrpcClient.Object, null);
Note response = client.UpdateNote(request);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public async Task <bool> UpdateNote(UpdateNoteRequest request)
{
var userId = CurrentlyLoggedUser.Id;
try
{
var note = await _context.Set <Note>().Where(n => n.Id == request.NoteId && n.UserId == userId).SingleOrDefaultAsync();
note.Title = request.Title;
note.Content = request.Content;
note.PriorityId = request.PriorityId;
note.EventDate = request.EventDate;
note.NotificationDate = request.NotificationDate;
await _context.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public UserNoteResponseData UpdateNote(int userID, int noteID, UpdateNoteRequest updateNoteRequest)
{
UserNoteResponseData userNoteResponseData = _userNoteRepository.UpdateNote(userID, noteID, updateNoteRequest);
return(userNoteResponseData);
}
public async Task Post([FromBody] UpdateNoteRequest newNoteRequest)
{
await _accountService.UpdateUserNotes(_account, newNoteRequest.Notes);
}
