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