public async Task UpdateContactAsync_NotExistingContactId_ShouldThrowFactroApiException()
{
// Arrange
await this.fixture.ClearFactroInstanceAsync();
var contactApi = this.fixture.GetService <IContactApi>();
var updatedDescription = $"{BaseTestFixture.TestPrefix}{Guid.NewGuid().ToString()}";
var updateContactRequest = new UpdateContactRequest
{
Description = updatedDescription,
};
var updateContactResponse = default(UpdateContactResponse);
// Act
Func <Task> act = async() => updateContactResponse = await contactApi.UpdateContactAsync(Guid.NewGuid().ToString(), updateContactRequest);
// Assert
await act.Should().ThrowAsync <FactroApiException>();
using (new AssertionScope())
{
var contacts = await this.fixture.GetContactsAsync(contactApi);
contacts.All(x => x.Description != updatedDescription).Should().BeTrue();
updateContactResponse.Should().BeNull();
}
await this.fixture.ClearFactroInstanceAsync();
}
public void Arrange()
{
Setup();
_updateContactRequest = new UpdateContactRequest();
_validationResult = UpdateContactRequestValidator.Validate(_updateContactRequest);
}
public async Task UpdateContactAsync_InvalidUpdate_ShouldNotUpdateContact()
{
// Arrange
await this.fixture.ClearFactroInstanceAsync();
var contactApi = this.fixture.GetService <IContactApi>();
var existingContact = await this.fixture.CreateTestContactAsync(contactApi);
const string updatedDescription = null;
var updateContactRequest = new UpdateContactRequest
{
Description = updatedDescription,
};
// Act
Func <Task> act = async() => await contactApi.UpdateContactAsync(existingContact.Id, updateContactRequest);
// Assert
await act.Should().NotThrowAsync();
var contacts = await this.fixture.GetContactsAsync(contactApi);
contacts.Single(x => x.Id == existingContact.Id).Should().BeEquivalentTo(existingContact);
await this.fixture.ClearFactroInstanceAsync();
}
public async Task <JsonResult> Update([FromBody] UpdateContactRequest request, Guid guid)
{
request.Guid = guid;
var result = await _identityServiceWrapper.UpdateContact(request);
return(new JsonResult(result));
}
public async stt::Task UpdateContactAsync()
{
moq::Mock <EssentialContactsService.EssentialContactsServiceClient> mockGrpcClient = new moq::Mock <EssentialContactsService.EssentialContactsServiceClient>(moq::MockBehavior.Strict);
UpdateContactRequest request = new UpdateContactRequest
{
Contact = new Contact(),
UpdateMask = new wkt::FieldMask(),
};
Contact expectedResponse = new Contact
{
ContactName = ContactName.FromProjectContact("[PROJECT]", "[CONTACT]"),
Email = "email7cf5830c",
NotificationCategorySubscriptions =
{
NotificationCategory.TechnicalIncidents,
},
LanguageTag = "language_tag40256b15",
ValidationState = ValidationState.Invalid,
ValidateTime = new wkt::Timestamp(),
};
mockGrpcClient.Setup(x => x.UpdateContactAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Contact>(stt::Task.FromResult(expectedResponse), null, null, null, null));
EssentialContactsServiceClient client = new EssentialContactsServiceClientImpl(mockGrpcClient.Object, null);
Contact responseCallSettings = await client.UpdateContactAsync(request.Contact, request.UpdateMask, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
Contact responseCancellationToken = await client.UpdateContactAsync(request.Contact, request.UpdateMask, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
public async void PushBulletUpdateContactTest()
{
try
{
var contacts = await Client.CurrentUsersContacts();
Assert.IsNotNull(contacts);
var contact = contacts.Contacts.FirstOrDefault(o => o.Email == "*****@*****.**");
Assert.IsNotNull(contact);
UpdateContactRequest request = new UpdateContactRequest()
{
Name = "Not A Real Person",
ContactIden = contact.Iden
};
var result = Client.UpdateContact(request);
Assert.IsNotNull(result);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
public async Task <IActionResult> Update([FromRoute] Guid contactId, [FromBody] UpdateContactRequest contactRequest)
{
var isOwner = await _contactService.CheckUserForOwnership(contactId, HttpContext.GetCurrentUserId());
if (!isOwner)
{
return(BadRequest(new { error = "You are not the owner of this contact" }));
}
var contact = await _contactService.GetAsync(contactId);
contact.FirstName = contactRequest.FirstName;
contact.LastName = contactRequest.LastName;
contact.CompanyName = contactRequest.CompanyName;
var updated = await _contactService.UpdateAsync(contact);
if (updated)
{
await _redisCacheService
.DeleteCachedResponseAsync(
new string[]
{
HttpContext.Request.Path,
APIRoutes.ContactControllerRoutes.GetAll
});
return(Ok(contact));
}
return(NotFound());
}
public void UpdateContact()
{
moq::Mock <EssentialContactsService.EssentialContactsServiceClient> mockGrpcClient = new moq::Mock <EssentialContactsService.EssentialContactsServiceClient>(moq::MockBehavior.Strict);
UpdateContactRequest request = new UpdateContactRequest
{
Contact = new Contact(),
UpdateMask = new wkt::FieldMask(),
};
Contact expectedResponse = new Contact
{
ContactName = ContactName.FromProjectContact("[PROJECT]", "[CONTACT]"),
Email = "email7cf5830c",
NotificationCategorySubscriptions =
{
NotificationCategory.TechnicalIncidents,
},
LanguageTag = "language_tag40256b15",
ValidationState = ValidationState.Invalid,
ValidateTime = new wkt::Timestamp(),
};
mockGrpcClient.Setup(x => x.UpdateContact(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
EssentialContactsServiceClient client = new EssentialContactsServiceClientImpl(mockGrpcClient.Object, null);
Contact response = client.UpdateContact(request.Contact, request.UpdateMask);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public async Task UpdateContactAsync_ValidUpdate_ShouldReturnUpdatedContact()
{
// Arrange
await this.fixture.ClearFactroInstanceAsync();
var contactApi = this.fixture.GetService <IContactApi>();
var existingContact = await this.fixture.CreateTestContactAsync(contactApi);
var updatedDescription = $"{BaseTestFixture.TestPrefix}{Guid.NewGuid().ToString()}";
var updateContactRequest = new UpdateContactRequest
{
Description = updatedDescription,
};
var updateContactResponse = new UpdateContactResponse();
// Act
Func <Task> act = async() => updateContactResponse = await contactApi.UpdateContactAsync(existingContact.Id, updateContactRequest);
// Assert
await act.Should().NotThrowAsync();
using (new AssertionScope())
{
var contacts = (await this.fixture.GetContactsAsync(contactApi)).ToList();
contacts.Should().ContainEquivalentOf(updateContactResponse);
contacts.Single(x => x.Id == existingContact.Id).Description.Should().Be(updatedDescription);
}
await this.fixture.ClearFactroInstanceAsync();
}
public async void TestUpdateWithTeam()
{
String accessToken = this.RandomString();
String teamId = this.RandomString();
Models.Contact contact = new Models.Contact();
contact.ContactData = new Models.ContactData();
contact.ContactId = this.RandomString();
contact.ContactData.Name = new Models.Fields.Name();
contact.ContactData.Name.FamilyName = this.RandomString();
UpdateContactRequest req = new UpdateContactRequest();
req.Contact = contact;
req.TeamId = teamId;
MockAPI <Contacts> mock = this.MockFor <Contacts>(
HttpMethod.Post,
"/api/v1/contacts.update",
m => m.WithContent(req.ToString())
.Respond("application/json", req.ToString())
);
APIResponse <ContactResponseBody> res = await mock.Instance.Update(accessToken, contact, teamId);
mock.Handler.VerifyNoOutstandingExpectation();
Assert.Equal(contact.ContactId, res.Body.Contact.ContactId);
}
private UpdateContactResponse Update(string url, UpdateContactRequest model)
{
UpdateContactResponse updateResponse = new UpdateContactResponse();
Synergy.Common.Request.WebClient client = new Common.Request.WebClient();
var requestModel = model.ConvertToUpdateContactPropertyRequest();
string requestData = GetJson(requestModel);
HttpWebResponse response = client.Put(JsonConvert.SerializeObject(requestModel), GetUrl(url), GetAuthorization(), EnumUtilities.GetDescriptionFromEnumValue(ContentTypes.JSON));
if (response.StatusCode == HttpStatusCode.OK)
{
var responseStream = response.GetResponseStream();
StreamReader streamReader = new StreamReader(responseStream);
string rawResponse = streamReader.ReadToEnd();
var Contact = JsonConvert.DeserializeObject <Contact>(rawResponse);
updateResponse.Status = Status.Success;
}
else
{
var responseStream = response.GetResponseStream();
StreamReader streamReader = new StreamReader(responseStream);
string rawResponse = streamReader.ReadToEnd();
updateResponse.Message = rawResponse;
updateResponse.Status = Status.Error;
}
return(updateResponse);
}
public async Task <ContactResponse> Update(UpdateContactRequest updateContactRequest)
{
using (var request = new HttpRequestMessage(HttpMethod.Put, $"/api/v1/contacts/"))
{
return(await PostPutRequestWithResponse <UpdateContactRequest, ContactResponse>(request, updateContactRequest));
}
}
public IActionResult UpdateContact(UpdateContactRequest request)
{
if (request == null)
{
return(BadRequest());
}
return(Ok(contactRepository.UpdateContact(request)));
}
public async Task <IActionResult> UpdateContact([FromBody] UpdateContactRequest updateContactRequest)
{
_logger.LogInformation("Received Update Contact Request");
await _mediator.Send(updateContactRequest);
return(NoContent());
}
public static object ConvertToUpdateContactPropertyRequest(this UpdateContactRequest model)
{
return(new
{
id = model.Id,
properties = model.Property.ConvertToPropertyList()
});
}
public void Update(string contactId, UpdateContactRequest updateContact)
{
var request = base.BuildRequest(Method.PATCH);
request.Resource += "/{contactId}";
request.AddParameter("contactId", contactId, ParameterType.UrlSegment);
_client.Execute <Contact>(request, updateContact);
}
//TODO-> Add bad request response
public async Task <IActionResult> Update([FromRoute] Guid id, [FromBody] UpdateContactRequest request)
{
var userOwnsContact = await _contactService.UserOwnsContactAsync(id, HttpContext.GetUserId());
if (!userOwnsContact)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var contact = await _contactService.GetContactByIdAsync(id);
if (contact == null)
{
return(NotFound());
}
if (request.Firstname != null)
{
contact.Firstname = request.Firstname;
}
if (request.Lastname != null)
{
contact.Lastname = request.Lastname;
}
if (request.Fullname != null)
{
contact.Fullname = request.Fullname;
}
else if (request.Firstname != null || request.Lastname != null)
{
contact.Fullname = $"{contact.Firstname} {contact.Lastname}";
}
if (request.Phone != null)
{
contact.Phone = request.Phone;
}
if (request.Email != null)
{
contact.Email = request.Email;
}
if (request.Address != null)
{
contact.Address = request.Address;
}
var updated = await _contactService.UpdateContact(contact);
if (updated)
{
return(Ok(new Response <Contact>(contact)));
}
return(NotFound());
}
public IHttpActionResult Put(
[FromUri] UpdateContactRequest request,
[FromBody] Delta <WriteContactPayload> payload)
{
request.Payload = payload;
var contact = _updateContactProcessor.Process(request);
return(Ok(contact));
}
public async Task Arrange()
{
Setup();
Builder <ContactResponse> .CreateNew().Build();
_updateContactRequest = Builder <UpdateContactRequest> .CreateNew().Build();
await ContactController.UpdateContact(_updateContactRequest);
}
public ActionResult EditContact(UpdateContactRequest model)
{
model.UserId = SynergySecurity.GetCurrentUser();
model.Api = ApiTypes.AgileCrm;
model.Request = "Update Contact details";
var RecordId = SynergySecurity.ToLog <UpdateContactRequest>(model);
UpdateContactResponse response = contactApi.UpdateContactProperty(model);
SynergySecurity.ToUpdateLog <UpdateContactResponse>(response, RecordId);
return(RedirectToAction("Contacts"));
}
public HttpResponseMessage UpdateContact(UpdateContactRequest model)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
SuccessResponse response = new SuccessResponse();
ContactsService.UpdateContact(model);
return(Request.CreateResponse(response));
}
public async Task UpdateContactAsync_InvalidContactId_ShouldThrowArgumentNullException(string contactId)
{
// Arrange
var contactApi = this.fixture.GetContactApi();
var updateContactRequest = new UpdateContactRequest();
// Act
Func <Task> act = async() => await contactApi.UpdateContactAsync(contactId, updateContactRequest);
// Assert
await act.Should().ThrowAsync <ArgumentNullException>();
}
public void Arrange()
{
Setup();
_updateContactRequest = Builder <UpdateContactRequest>
.CreateNew()
.With(q => q.Email = "*****@*****.**")
.Build();
ContactQueryRepositoryMock.Setup(q => q.CheckContactExists(Moq.It.IsAny <string>()))
.Returns(Task.FromResult(true));
_validationResult = UpdateContactRequestValidator.Validate(_updateContactRequest);
}
/// <summary>
/// Update a contact with new details.
///
/// c.f. https://developers.freshdesk.com/api/#update_contact
/// </summary>
///
/// <param name="contactId">
/// The unique identifier for the contact.
/// </param>
///
/// <param name="request">
/// The details about the contact to update.
/// </param>
///
/// <param name="cancellationToken"></param>
///
/// <returns>The newly updated contact</returns>
public async Task <Contact> UpdateContactAsync(
long contactId,
UpdateContactRequest request,
CancellationToken cancellationToken = default)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request), "Request must not be null");
}
return(await _freshdeskClient
.ApiOperationAsync <Contact>(HttpMethod.Put, $"/api/v2/contacts/{contactId}", request, cancellationToken)
.ConfigureAwait(false));
}
public IActionResult Put(UpdateContactRequest request, [FromHeader] string authorization)
{
IActionResult error = GetError(request);
if (error != null)
{
return(error);
}
UserReadDbo user = _auth.ValidateUser(authorization);
if (user == null)
{
return(_auth.GetError());
}
DateTime?birthdate = null;
if (!string.IsNullOrEmpty(request.Birthdate))
{
DateTime dt;
if (DateTime.TryParse(request.Birthdate, out dt))
{
birthdate = dt;
}
else
{
return(Error.BadRequest("Invalid birthdate"));
}
}
DateTime now = DateTime.UtcNow;
ContactUpdateDbo dbo = new ContactUpdateDbo
{
Name = request.Name,
Birthdate = birthdate,
Favorite = request.Favorite,
GroupId = request.GroupId,
Description = request.Description,
UpdatedAt = now,
};
if (!_repo.UpdateContact(dbo, request.Id))
{
return(NotFound());
}
return(Ok());
}
public bool UpdateContact(UpdateContactRequest request)
{
if (request != null)
{
var contact = _db.Contacts.Where(a => a.Id == request.ContactId).FirstOrDefault();
if (contact != null)
{
contact.Mobile = request.Phone;
contact.Email = request.Email;
_db.SaveChanges();
return(true);
}
}
return(false);
}
/// <summary>Snippet for UpdateContact</summary>
public void UpdateContactRequestObject()
{
// Snippet: UpdateContact(UpdateContactRequest, CallSettings)
// Create client
EssentialContactsServiceClient essentialContactsServiceClient = EssentialContactsServiceClient.Create();
// Initialize request argument(s)
UpdateContactRequest request = new UpdateContactRequest
{
Contact = new Contact(),
UpdateMask = new FieldMask(),
};
// Make the request
Contact response = essentialContactsServiceClient.UpdateContact(request);
// End snippet
}
private List <UpdateContactRequest> ToUpdateContactRequestList(GetContactsResponse response)
{
List <Contact> contacts = response.Contacts;
List <UpdateContactRequest> model = new List <UpdateContactRequest>();
foreach (var item in contacts)
{
UpdateContactRequest request = new UpdateContactRequest()
{
Id = item.id,
Property = ToConvertContactProperty(item)
};
model.Add(request);
}
return(model);
}
public async Task UpdateContactAsync_ValidRequest_ShouldReturnUpdatedContact()
{
// Arrange
var existingContact = new GetContactPayload
{
Id = Guid.NewGuid().ToString(),
Description = "TestDescription",
};
var updateContactRequest = new UpdateContactRequest
{
Description = "NewDescription",
};
var expectedUpdatedContact = new UpdateContactResponse
{
Id = existingContact.Id,
Description = updateContactRequest.Description,
};
var expectedResponseContent =
new StringContent(JsonConvert.SerializeObject(expectedUpdatedContact, this.fixture.JsonSerializerSettings));
var expectedResponse = new HttpResponseMessage
{
Content = expectedResponseContent,
};
var contactApi = this.fixture.GetContactApi(expectedResponse);
var updateContactResponse = new UpdateContactResponse();
// Act
Func <Task> act = async() =>
updateContactResponse = await contactApi.UpdateContactAsync(existingContact.Id, updateContactRequest);
// Assert
await act.Should().NotThrowAsync();
using (new AssertionScope())
{
updateContactResponse.Id.Should().Be(existingContact.Id);
updateContactResponse.Description.Should().Be(expectedUpdatedContact.Description);
}
}
public async Task <StatusCodeResult> Put(Guid id, UpdateContactRequest request)
{
if (id != request.Id)
{
return(BadRequest());
}
var mapped = _mapper.Map <ContactDto>(request);
var result = await _contactsService.UpdateContactAsync(mapped);
if (result == false)
{
return(BadRequest());
}
return(Ok());
}