public async Task <ContactUpdateResponse> UpdateContactAsync(ContactUpdateRequest req)
{
using (var conn = new SqlConnection(_connectionSettings.DefaultConnection))
{
var result = new ContactUpdateResponse();
string storeproc = string.Format("[dbo].[usp{0}Update_New]", req.ContactType);
await conn.OpenAsync();
var dynParm = new
{
req.Contact.Id,
req.Contact.Address,
req.Contact.City,
req.Contact.ContactName,
req.Contact.Name,
req.Contact.Phone,
req.Contact.State,
req.Contact.Zip,
req.Contact.UpdatedBy,
req.Contact.UpdatedDate
};
var rawResult = await conn.QueryAsync <ContactDTO>(storeproc, dynParm, null, null, CommandType.StoredProcedure);
if (rawResult != null)
{
result.Data = rawResult.FirstOrDefault();
result.Data.ContactType = req.ContactType;
}
return(result);
}
}
//update contact
public async Task UpdateContact(int userId, ContactUpdateRequest updateRequest)
{
var request = new UpdateItemRequest
{
TableName = TableName,
Key = new Dictionary <string, AttributeValue>
{
{ "UserId", new AttributeValue {
N = userId.ToString()
} },
{ "Email", new AttributeValue {
S = updateRequest.Email
} }
},
AttributeUpdates = new Dictionary <string, AttributeValueUpdate>
{
{ "Phone", new AttributeValueUpdate
{
Action = AttributeAction.PUT,
Value = new AttributeValue {
S = updateRequest.Phone
}
} },
{ "FullName", new AttributeValueUpdate
{
Action = AttributeAction.PUT,
Value = new AttributeValue {
S = updateRequest.FullName
}
} },
}
};
await _dynamoDbClient.UpdateItemAsync(request);
}
public async Task When_UpdateContactAsyncIsInvoked_And_HubspotReturnsOkStatus_Then_ResponseMustBeAContactSuccessResponse()
{
// arrange
const string responseFixture = "fixtures/hubspot-contact-update-response.json";
const string expectedId = "someid";
var request = new ContactUpdateRequest {
Id = expectedId
};
var cancellationToken = new CancellationTokenSource().Token;
this.wireMockServer
.Given(Request.Create()
.UsingPatch()
.WithPath($"/crm/v3/objects/contacts/{expectedId}")
.WithParam(ApiKeyParamName, DefaultApiKey)
.WithBody(new JsonMatcher(@"{""properties"":{}}"))
.WithHeader("Content-Type", "application/json; charset=utf-8")
.WithHeader("Accept", "application/json"))
.RespondWith(Response.Create()
.WithStatusCode(HttpStatusCode.OK)
.WithBodyFromFile(responseFixture, cache: true)
.WithHeader("Content-Type", "application/json; charset=utf-8"));
// act
var response = await this.systemUnderTest.UpdateContactAsync(request, cancellationToken);
// assert
Assert.IsType <ContactSuccessResponse>(response);
}
public async Task <IActionResult> Detail()
{
var contact = await _contactApiClient.GetcontactInfos();
var updateModel = new ContactUpdateRequest()
{
adress = contact.ResultObject.adress,
imageBase64 = contact.ResultObject.company_logo,
email = contact.ResultObject.email,
company_name = contact.ResultObject.company_name,
fax = contact.ResultObject.fax,
hotline = contact.ResultObject.hotline,
id = contact.ResultObject.id,
phone = contact.ResultObject.phone,
social_fb = contact.ResultObject.social_fb,
social_instagram = contact.ResultObject.social_instagram,
social_twitter = contact.ResultObject.social_twitter,
social_youtube = contact.ResultObject.social_youtube
};
if (TempData["result"] != null)
{
ViewBag.SuccessMsg = TempData["result"];
}
if (TempData["error"] != null)
{
ViewBag.ErrorMsg = TempData["error"];
}
return(View(updateModel));
}
public async Task <IActionResult> ContactUpdateAsync(ContactUpdateRequest req)
{
req.Contact.UpdatedBy = User.CurrentUserName();
var result = await _contactManager.UpdateContactAsync(req);
return(Ok(result));
}
public async Task <ContactUpdateResponse> UpdateContactAsync(int id, ContactUpdateRequest updateRequest)
{
var retVal = new ContactUpdateResponse();
try
{
// using a stored procedure here is not normally needed, but is also not harmful.
var resultAsync = await _connection.QueryMultipleAsync("usp_Contact_Update",
new
{
id,
updateRequest.FirstName,
updateRequest.LastName,
updateRequest.EMail,
updateRequest.TelephoneNumber_Entry,
updateRequest.Updater
}
, commandType : CommandType.StoredProcedure);
var result = resultAsync.ReadSingleOrDefault <Domain.DomainModels.Contact.Contact>();
retVal.Success = true;
retVal.Contact = result;
}
catch (Exception ex)
{
retVal.Success = false;
retVal.Message = ex.Message;
}
return(retVal);
}
public ApiResponse <ContactUpdateResponse> Update(ContactUpdateRequest request)
{
return(this.Send <ContactUpdateResponse>(new ApiRequest
{
Service = "contact.update",
Data = request
}));
}
public void When_ContactUpdateRequestIsPassed_If_HttpClientHasNullBaseAddress_Then_AnArgumentNullExceptionMustBeThrown()
{
// arrange
var httpClient = new HttpClient();
var request = new ContactUpdateRequest();
// act and assert
Assert.Throws <ArgumentNullException>(() => request.MapToHttpRequestMessage(httpClient));
}
public async Task <IActionResult> Update([FromForm] ContactUpdateRequest request)
{
var result = await _contactService.Update(request);
if (!result.IsSuccess)
{
return(BadRequest(result));
}
return(Ok(result));
}
public async Task When_UpdateContactAsyncIsInvoked_And_RequestIsNull_Then_ArgumentNullExceptionMustBeThrown()
{
// arrange
var cancellationToken = new CancellationTokenSource().Token;
ContactUpdateRequest request = null;
// act and assert
var err = await Assert.ThrowsAsync <ArgumentNullException>(() => this.systemUnderTest.UpdateContactAsync(request, cancellationToken));
Assert.Equal("request", err.ParamName);
}
public async Task <ActionResult> Update(string id, [FromBody] ContactUpdateRequest rq)
{
try
{
ContactUpdateResponse rs = await(new ContactUpdateService(this.Context, _contactModRepo)).RunAsync(rq);
return(new ApiActionResult(this.Context.Request, rs));
}
catch (Exception ex)
{
return(new ApiActionResult(this.Context.Request, ex));
}
}
/// <summary>
/// Maps a ContactUpdateRequest to HttpRequestMessage.
/// </summary>
/// <param name="request">Instance of <see cref="ContactUpdateRequest" />.</param>
/// <param name="httpClient">Instance of <see cref="HttpClient" />.</param>
/// <returns>A <see cref="HttpRequestMessage" /> object.</returns>
internal static HttpRequestMessage MapToHttpRequestMessage(
this ContactUpdateRequest request,
HttpClient httpClient)
{
var path = $"{BasePath}/{request.Id}";
var method = new HttpMethod("PATCH");
var requestUri = new Uri(path, UriKind.Relative);
var body = new { properties = request.Properties };
return(GenerateRequestMessage(
httpClient.GenerateRequestUri(requestUri),
method,
body));
}
public void When_ContactUpdateRequestIsPassed_Then_HttpRequestContentTypeMustBeApplicationJsonWithUtf8Charset()
{
// arrange
const string expectedContentType = "application/json; charset=utf-8";
var httpClient = new HttpClient {
BaseAddress = new Uri("http://localhost")
};
var request = new ContactUpdateRequest();
// act
var httpRequest = request.MapToHttpRequestMessage(httpClient);
// assert
Assert.Equal(expectedContentType, httpRequest.Content.Headers.GetValues("Content-Type").First());
}
public async Task <ActionResult> UpdateContact(int id, [FromBody] ContactUpdateRequest request)
{
var contact = await _context.FindContact(id);
if (contact == default)
{
return(new NotFoundResult());
}
contact.Update(request.Name, request.Address, request.Type, request.Vat);
var updatedContact = await _context.UpdateContact(contact);
return(new JsonResult(MapToResponse(updatedContact)));
}
public void When_ContactUpdateRequestIsPassed_Then_HttpRequestAcceptHeaderMustBeApplicationJson()
{
// arrange
const string expectedAccept = "application/json";
var httpClient = new HttpClient {
BaseAddress = new Uri("http://localhost")
};
var request = new ContactUpdateRequest();
// act
using (var httpRequest = request.MapToHttpRequestMessage(httpClient))
{
// assert
Assert.Equal(expectedAccept, httpRequest.Headers.GetValues("Accept").First());
}
}
public async Task <IActionResult> Update(ContactUpdateRequest request)
{
if (!ModelState.IsValid)
{
return(View("Detail", request));
}
var result = await _contactApiClient.UpdateContact(request);
if (result.IsSuccess)
{
TempData["result"] = "Cập nhật thành công";
return(RedirectToAction("Detail"));
}
ModelState.AddModelError("", result.Message);
return(View("Detail", request));
}
public void When_ContactUpdateRequestIsPassed_Then_HttpRequestMethodMustBePatch()
{
// arrange
var httpClient = new HttpClient {
BaseAddress = new Uri("http://localhost")
};
var request = new ContactUpdateRequest {
Id = "someid"
};
// act
using (var httpRequest = request.MapToHttpRequestMessage(httpClient))
{
// assert
Assert.Equal(new HttpMethod("PATCH"), httpRequest.Method);
}
}
/// <inheritdoc/>
public async Task <BaseContactResponse> UpdateContactAsync(ContactUpdateRequest request, CancellationToken cancellationToken)
{
if (request is null)
{
throw new System.ArgumentNullException(nameof(request));
}
if (string.IsNullOrWhiteSpace(request.Id))
{
throw new System.ArgumentNullException(nameof(request.Id));
}
using (var httpRequest = request.MapToHttpRequestMessage(this.httpClient))
using (var httpResponse = await this.httpClient.SendAndLogAsync(httpRequest, this.logger, cancellationToken))
{
return(await httpResponse.MapToUpdateContactResponse());
}
}
public void When_ContactUpdateRequestIsPassed_Then_HttpRequestBodyMustBeCorrect()
{
// arrange
var expectedBody = @"{""properties"":{}}";
var httpClient = new HttpClient {
BaseAddress = new Uri("http://localhost")
};
var request = new ContactUpdateRequest {
Id = "someid"
};
// act
using (var httpRequest = request.MapToHttpRequestMessage(httpClient))
{
// assert
var body = httpRequest.Content.ReadAsStringAsync().Result;
Assert.Equal(expectedBody, body);
}
}
public async Task <ApiResult <bool> > Update(ContactUpdateRequest request)
{
var contact = await _context.Contacts.FindAsync(request.Id);
if (contact == null)
{
return(new ApiErrorResult <bool>(SystemConstants.Message.CanNotFindIdMessage + "comment table with Id: " + request.Id));
}
contact.Name = request.Name;
contact.Message = request.Message;
contact.Email = request.Email;
contact.PhoneNumber = request.PhoneNumber;
contact.Status = request.Status;
await _context.SaveChangesAsync();
return(new ApiSuccessResult <bool>());
}
public void When_ContactUpdateRequestIsPassed_Then_HttpRequestUriMustBeCorrect()
{
// arrange
const string expectedId = "someid";
var expectedUri = $"http://localhost/crm/v3/objects/contacts/{expectedId}";
var httpClient = new HttpClient {
BaseAddress = new Uri("http://localhost")
};
var request = new ContactUpdateRequest {
Id = expectedId
};
// act
using (var httpRequest = request.MapToHttpRequestMessage(httpClient))
{
// assert
Assert.Equal(expectedUri, httpRequest.RequestUri.ToString());
}
}
public async Task <ActionResult> Edit(int?id, [Bind(Include = "FirstName, LastName, EMail, TelephoneNumber_Entry")] ContactViewModel editModel)
{
var req = new ContactUpdateRequest
{
Id = id ?? editModel.Id,
FirstName = editModel.FirstName,
LastName = editModel.LastName,
EMail = editModel.EMail,
TelephoneNumber_Entry = editModel.TelephoneNumber_Entry,
Updater = "SystemFakeUser"
};
if (ModelState.IsValid)
{
var result = await _contactRepository.UpdateContactAsync(req.Id, req);
if (result.Success)
{
this.AddToastMessage(@Resource.Resource.Toast_Success,
@Resource.Resource.UpdateContact_Toast_Success, ToastType.Success);
return(View(result.Contact.ConvertToViewModel()));
}
var vm = new GenericErrorVM {
ErrorMessage = result.Message
};
this.AddToastMessage(result.Message, @Resource.Resource.UpdateContact_Toast_Failure, ToastType.Error);
Log.Error(null, result.Message);
return(View("../GenericError/GenericError", vm));
}
else
{
return(View(editModel));
}
}
public async Task <ApiResult <bool> > Update(ContactUpdateRequest request)
{
try
{
var result = await _context.Contacts.FindAsync(request.id);
if (result != null)
{
if (request.company_logo != null)
{
await _storageService.DeleteFileAsync(result.company_logo);
result.company_logo = await this.SaveFile(request.company_logo);
}
result.adress = request.adress;
result.company_name = request.company_name;
result.email = request.email;
result.fax = request.fax;
result.hotline = request.hotline;
result.phone = request.phone;
result.social_fb = request.social_fb;
result.social_instagram = request.social_instagram;
result.social_twitter = request.social_twitter;
result.social_youtube = request.social_youtube;
await _context.SaveChangesAsync();
return(new ApiSuccessResult <bool>());
}
else
{
return(new ApiErrorResult <bool>("Dữ liệu liên hệ trống"));
}
}
catch
{
return(new ApiErrorResult <bool>("Cập nhật thất bại"));
}
}
public async Task <IActionResult> UpdateContact(int userId, [FromBody] ContactUpdateRequest request)
{
await _contactService.UpdateContact(userId, request);
return(Ok());
}
private void SendContactRequest()
{
Debug.Log("Sending request for Contacts update.");
ContactUpdateRequest request = new ContactUpdateRequest();
request.Clients.Add(this.m_guiContacts.Clients);
this.m_localClient.SendMessage(MessageType.ContactUpdateRequest, request);
}
public async Task <ApiResult <bool> > UpdateContact(ContactUpdateRequest request)
{
var client = _httpClientFactory.CreateClient();
client.BaseAddress = new Uri(_configuration["BaseAddress"]);
var requestContent = new MultipartFormDataContent();
if (request.company_logo != null)
{
byte[] data;
using (var br = new BinaryReader(request.company_logo.OpenReadStream()))
{
data = br.ReadBytes((int)request.company_logo.OpenReadStream().Length);
}
ByteArrayContent bytes = new ByteArrayContent(data);
requestContent.Add(bytes, "company_logo", request.company_logo.FileName);
}
requestContent.Add(new StringContent(request.adress.ToString()), "adress");
requestContent.Add(new StringContent(request.company_name.ToString()), "company_name");
requestContent.Add(new StringContent(request.email.ToString()), "email");
requestContent.Add(new StringContent(request.id.ToString()), "id");
requestContent.Add(new StringContent(request.phone.ToString()), "phone");
if (!string.IsNullOrEmpty(request.hotline))
{
requestContent.Add(new StringContent(request.hotline.ToString()), "hotline");
}
if (!string.IsNullOrEmpty(request.fax))
{
requestContent.Add(new StringContent(request.fax.ToString()), "fax");
}
if (!string.IsNullOrEmpty(request.social_fb))
{
requestContent.Add(new StringContent(request.social_fb.ToString()), "social_fb");
}
if (!string.IsNullOrEmpty(request.social_instagram))
{
requestContent.Add(new StringContent(request.social_instagram.ToString()), "social_instagram");
}
if (!string.IsNullOrEmpty(request.social_twitter))
{
requestContent.Add(new StringContent(request.social_twitter.ToString()), "social_twitter");
}
if (!string.IsNullOrEmpty(request.social_youtube))
{
requestContent.Add(new StringContent(request.social_youtube.ToString()), "social_youtube");
}
var respone = await client.PutAsync($"/api/Contact", requestContent);
var result = await respone.Content.ReadAsStringAsync();
if (respone.IsSuccessStatusCode)
{
return(JsonConvert.DeserializeObject <ApiSuccessResult <bool> >(result));
}
else
{
return(JsonConvert.DeserializeObject <ApiErrorResult <bool> >(result));
}
}
//contact contact
public async Task UpdateContact(int userId, ContactUpdateRequest request)
{
await _contactRepository.UpdateContact(userId, request);
}
public async Task <ContactUpdateResponse> UpdateContactAsync(ContactUpdateRequest req)
{
req.Contact.UpdatedDate = DateTime.Today;
return(await _repos.UpdateContactAsync(req));
}
