public async Task ShouldCreateContactBeOkHavingProvidedData()
{
//Conteggio gli elementi prima della creazione
var countBefore = Scenario.Contacts.Count;
//Composizione della request
var request = new ContactCreateRequest
{
Name = RandomizationUtils.GenerateRandomString(50),
Token = RandomizationUtils.GenerateRandomString(50),
Description = RandomizationUtils.GenerateRandomString(50),
Email = RandomizationUtils.GenerateRandomEmail(),
Subject = RandomizationUtils.GenerateRandomString(50),
AcceptPolicy = true,
};
//Invoke del metodo
var response = await Controller.CreateContact(request);
//Conteggio gli elementi dopo la creazione
var countAfter = Scenario.Contacts.Count;
var lastInsert = Scenario.Contacts.OrderByDescending(x => x.CreationDateTime).FirstOrDefault();
//Parsing della risposta e assert
var parsed = ParseExpectedOk <OkResponse>(response);
Assert.IsTrue(parsed != null &&
countAfter == countBefore + 1 &&
lastInsert != null &&
lastInsert.Name == request.Name &&
lastInsert.Description == request.Description &&
lastInsert.Email == request.Email &&
lastInsert.Subject == request.Subject
);
}
public async Task When_CreateContactAsyncIsInvoked_And_HubspotReturnsCreatedStatus_Then_ResponseMustBeAContactSuccessResponse()
{
// arrange
const string responseFixture = "fixtures/hubspot-contact-create-response.json";
var request = new ContactCreateRequest();
var cancellationToken = new CancellationTokenSource().Token;
this.wireMockServer
.Given(Request.Create()
.UsingPost()
.WithPath("/crm/v3/objects/contacts")
.WithParam(ApiKeyParamName, DefaultApiKey)
.WithBody(new JsonMatcher(@"{""properties"":{}}"))
.WithHeader("Content-Type", "application/json; charset=utf-8")
.WithHeader("Accept", "application/json"))
.RespondWith(Response.Create()
.WithStatusCode(HttpStatusCode.Created)
.WithBodyFromFile(responseFixture, cache: true)
.WithHeader("Content-Type", "application/json; charset=utf-8"));
// act
var response = await this.systemUnderTest.CreateContactAsync(request, cancellationToken);
// assert
Assert.IsType <ContactSuccessResponse>(response);
}
public ApiResponse <ContactCreateResponse> Create(ContactCreateRequest request)
{
return(this.Send <ContactCreateResponse>(new ApiRequest
{
Service = "contact.create",
Data = request
}));
}
public void When_ContactCreateRequestIsPassed_If_HttpClientHasNullBaseAddress_Then_AnArgumentNullExceptionMustBeThrown()
{
// arrange
var httpClient = new HttpClient();
var request = new ContactCreateRequest();
// act and assert
Assert.Throws <ArgumentNullException>(() => request.MapToHttpRequestMessage(httpClient));
}
public async Task When_CreateContactAsyncIsInvoked_And_RequestIsNull_Then_ArgumentNullExceptionMustBeThrown()
{
// arrange
var cancellationToken = new CancellationTokenSource().Token;
ContactCreateRequest request = null;
// act and assert
var err = await Assert.ThrowsAsync <ArgumentNullException>(() => this.systemUnderTest.CreateContactAsync(request, cancellationToken));
Assert.Equal("request", err.ParamName);
}
public async Task <IActionResult> CreateContact(ContactCreateRequest request)
{
var captchaService = ServiceResolver.Resolve <ICaptchaValidatorService>();
var captchaCheck = await captchaService.ValidateToken(request.Token);
if (!string.IsNullOrEmpty(captchaCheck))
{
return(BadRequest(new List <ValidationResult> {
new(captchaCheck)
}));
public async Task <ActionResult> Create([FromBody] ContactCreateRequest rq)
{
try
{
ContactCreateResponse rs = await(new ContactCreateService(this.Context, _contactRepo)).RunAsync(rq);
return(new ApiActionResult(this.Context.Request, rs));
}
catch (Exception ex)
{
return(new ApiActionResult(this.Context.Request, ex));
}
}
/// <inheritdoc/>
public async Task <BaseContactResponse> CreateContactAsync(ContactCreateRequest request, CancellationToken cancellationToken)
{
if (request is null)
{
throw new System.ArgumentNullException(nameof(request));
}
using (var httpRequest = request.MapToHttpRequestMessage(this.httpClient))
using (var httpResponse = await this.httpClient.SendAndLogAsync(httpRequest, this.logger, cancellationToken))
{
return(await httpResponse.MapToCreateContactResponse());
}
}
/// <summary>
/// Create a new contact with the specified information
/// </summary>
///
/// <param name="request">
/// All the details of the contact to be created.
/// </param>
///
/// <param name="cancellationToken"></param>
///
/// <returns>The newly created contact</returns>
public async Task <Contact> CreateContactAsync(
ContactCreateRequest request,
CancellationToken cancellationToken = default)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request), "Request must not be null");
}
return(await _freshdeskClient
.ApiOperationAsync <Contact>(HttpMethod.Post, "/api/v2/contacts", request, cancellationToken)
.ConfigureAwait(false));
}
/// <summary>
/// Maps a ContactCreateRequest to HttpRequestMessage.
/// </summary>
/// <param name="request">Instance of <see cref="ContactCreateRequest" />.</param>
/// <param name="httpClient">Instance of <see cref="HttpClient" />.</param>
/// <returns>A <see cref="HttpRequestMessage" /> object.</returns>
internal static HttpRequestMessage MapToHttpRequestMessage(
this ContactCreateRequest request,
HttpClient httpClient)
{
var method = HttpMethod.Post;
var requestUri = new Uri(BasePath, UriKind.Relative);
var body = new { properties = request.Properties };
return(GenerateRequestMessage(
httpClient.GenerateRequestUri(requestUri),
method,
body));
}
public async Task <ActionResult> CreateContact([FromBody] ContactCreateRequest request)
{
var company = await _context.FindCompany(request.CompanyId);
if (company == default)
{
return(new BadRequestResult());
}
var contact = new Contact(request.Name, request.Type, request.Address, request.Vat, company);
var createdContact = await _context.CreateContact(contact);
return(new JsonResult(MapToResponse(createdContact)));
}
public void When_ContactCreateRequestIsPassed_Then_HttpRequestContentTypeMustBeApplicationJsonWithUtf8Charset()
{
// arrange
const string expectedContentType = "application/json; charset=utf-8";
var httpClient = new HttpClient {
BaseAddress = new Uri("http://localhost")
};
var request = new ContactCreateRequest();
// act
var httpRequest = request.MapToHttpRequestMessage(httpClient);
// assert
Assert.Equal(expectedContentType, httpRequest.Content.Headers.GetValues("Content-Type").First());
}
public async Task <IActionResult> Create([FromForm] ContactCreateRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _contactService.Create(request);
if (!result.IsSuccess)
{
return(BadRequest(result));
}
return(Ok(result));
}
public void When_ContactCreateRequestIsPassed_Then_HttpRequestMethodMustBePost()
{
// arrange
var httpClient = new HttpClient {
BaseAddress = new Uri("http://localhost")
};
var request = new ContactCreateRequest();
// act
using (var httpRequest = request.MapToHttpRequestMessage(httpClient))
{
// assert
Assert.Equal(HttpMethod.Post, httpRequest.Method);
}
}
public void When_ContactCreateRequestIsPassed_Then_HttpRequestUriMustBeCorrect()
{
// arrange
const string expectedUri = "http://localhost/crm/v3/objects/contacts";
var httpClient = new HttpClient {
BaseAddress = new Uri("http://localhost")
};
var request = new ContactCreateRequest();
// act
using (var httpRequest = request.MapToHttpRequestMessage(httpClient))
{
// assert
Assert.Equal(expectedUri, httpRequest.RequestUri.ToString());
}
}
public void When_ContactCreateRequestIsPassed_Then_HttpRequestAcceptHeaderMustBeApplicationJson()
{
// arrange
const string expectedAccept = "application/json";
var httpClient = new HttpClient {
BaseAddress = new Uri("http://localhost")
};
var request = new ContactCreateRequest();
// act
using (var httpRequest = request.MapToHttpRequestMessage(httpClient))
{
// assert
Assert.Equal(expectedAccept, httpRequest.Headers.GetValues("Accept").First());
}
}
public async Task <ApiResult <bool> > Create(ContactCreateRequest request)
{
var contact = new Contact()
{
Name = request.Name,
Email = request.Email,
PhoneNumber = request.PhoneNumber,
Message = request.Message
};
var result = await _context.Contacts.AddAsync(contact);
await _context.SaveChangesAsync();
return(result == null
? new ApiErrorResult <bool>("Contact data can't create")
: new ApiSuccessResult <bool>());
}
public async Task <IActionResult> PostContact(ContactCreateRequest contactCreateRequest)
{
if (!ModelState.IsValid)
{
return(StatusCode(400));
}
var identityClaimNum = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
var dto = _mapper.Map <ContactCreateDTO>(contactCreateRequest);
dto.OwnerId = identityClaimNum;
if (await _contactCreateManager.ContactCreate(dto))
{
return(StatusCode(201)); //TODO: Return URL of new resource
}
return(StatusCode(500));
}
public void When_ContactCreateRequestIsPassed_Then_HttpRequestBodyMustBeCorrect()
{
// arrange
const string expectedBody = @"{""properties"":{""foo"":""bar""}}";
var httpClient = new HttpClient {
BaseAddress = new Uri("http://localhost")
};
var request = new ContactCreateRequest();
request.Properties.Add("foo", "bar");
// act
using (var httpRequest = request.MapToHttpRequestMessage(httpClient))
{
// assert
var body = httpRequest.Content.ReadAsStringAsync().Result;
Assert.Equal(expectedBody, body);
}
}
public async Task <ContactCreateResponse> ContactCreateAsync(ContactCreateRequest createRequest)
{
var response = new ContactCreateResponse();
var resultAsync = await _connection.QueryMultipleAsync("usp_Contact_Insert"
,
new
{
createRequest.FirstName,
createRequest.LastName,
createRequest.EMail,
createRequest.TelephoneNumber_Entry,
createRequest.Creator
}
, commandType : CommandType.StoredProcedure);
var contact = resultAsync.ReadSingleOrDefault <Domain.DomainModels.Contact.Contact>();
response.Contact = contact;
return(response);
}
public async Task <ActionResult> Create([Bind(Include = "FirstName, LastName, EMail, TelephoneNumber_Entry")] CreateContactViewModel createContactVModel)
{
try
{
if (ModelState.IsValid)
{
var req = new ContactCreateRequest
{
LastName = createContactVModel.LastName,
FirstName = createContactVModel.FirstName,
EMail = createContactVModel.EMail,
TelephoneNumber_Entry = createContactVModel.TelephoneNumber_Entry,
Creator = LoggedInUserFacade.UserName
};
var result = await _contactRepository.ContactCreateAsync(req);
this.AddToastMessage(@Resource.Resource.Toast_Success, @Resource.Resource.CreateContact_Toast_Success, ToastType.Success);
return(RedirectToAction("Edit", new { id = result.Contact.Id }));
}
}
catch (Exception ex)
{
ModelState.AddModelError("", @Resource.Resource.Model_Error_Unable_To_Perform_Action);
this.AddToastMessage(@Resource.Resource.CreateContact_Toast_Failure, ex.Message, ToastType.Error);
var em = new ContactCreateExceptionMessage {
Message = ex.Message
};
Log.Error(ex, ex.Message);
return(View("ContactCreationFailed", em));
}
return(View(createContactVModel));
}
public async Task <IActionResult> CreatePatientContactDetail(string patientId,
[FromBody] ContactCreateRequest create)
{
var contact = new Contact
{
Name = create.Name,
ContactInformation = create.ContactInformation,
NextOfKin = create.NextOfKin,
Notes = create.Notes,
Relationship = create.Relationship,
RelationshipCode = create.RelationshipCode,
RelationshipTerminology = create.RelationshipTerminology,
Author = create.Author,
DateCreated = DateTime.UtcNow,
Source = "qwed",
SourceId = $"{Guid.NewGuid()}",
PatientId = patientId
};
await this.Contacts.AddOrUpdate(contact);
return(this.Ok());
}
