public async Task Test1()
{
//given I have a test server and client
Setup();
//given I have a valid request
var request = new CreateContactRequest
{
FirstName = "testfirst",
LastName = "testlast",
PhoneNumber = 5555555555,
Address = "1234 Main Street",
City = "San Luis Obispo",
State = "CA",
Zip = "93401"
};
//given I have a contact to return
var contact = MapToContactFrom(request);
ContactsProviderMock.Setup(a => a.InsertContact(It.IsAny <Contact>()))
.Returns(Task.FromResult(contact));
//when I fetch the client
var httpResponse = await Client.PostAsJsonAsync(Url, request);
//then I expect the response
httpResponse.StatusCode.Should().Be(HttpStatusCode.OK);
var response = await httpResponse.Content.ReadAsAsync <CreateContactResponse>();
response.FirstName.Should().Be(request.FirstName);
response.LastName.Should().Be(request.LastName);
}
public async Task CreateContactAsync_TwoIdenticalContacts_ShouldStoreBothContacts()
{
// Arrange
await this.fixture.ClearFactroInstanceAsync();
var contactApi = this.fixture.GetService <IContactApi>();
var firstName = Guid.NewGuid().ToString();
var lastName = Guid.NewGuid().ToString();
var description = $"{BaseTestFixture.TestPrefix}{Guid.NewGuid().ToString()}";
var createContactRequest = new CreateContactRequest(firstName, lastName)
{
Description = description,
};
await contactApi.CreateContactAsync(createContactRequest);
// Act
Func <Task> act = async() => await contactApi.CreateContactAsync(createContactRequest);
// Assert
await act.Should().NotThrowAsync();
using (new AssertionScope())
{
var contacts = (await contactApi.GetContactsAsync())
.Where(x => x.Description.StartsWith(BaseTestFixture.TestPrefix)).ToList();
var matchingContacts = contacts.Where(x => x.Description == description);
matchingContacts.Should().HaveCount(2);
}
await this.fixture.ClearFactroInstanceAsync();
}
/// <summary>
/// Creates the new contact.
/// </summary>
/// <param name="request">The request.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentException">create contact request</exception>
/// <exception cref="System.Exception">
/// </exception>
public Contact CreateNewContact(CreateContactRequest request)
{
try
{
#region pre-processing
if (request == null)
{
throw new ArgumentException("create contact request");
}
if (string.IsNullOrWhiteSpace(request.Name))
{
throw new Exception(PushbulletConstants.CreateContactErrorMessages.ErrorNameProperty);
}
if (string.IsNullOrWhiteSpace(request.Email))
{
throw new Exception(PushbulletConstants.CreateContactErrorMessages.ErrorEmailProperty);
}
#endregion pre-processing
#region processing
Contact response = PostRequest <Contact>(string.Concat(PushbulletConstants.BaseUrl, PushbulletConstants.ContactsUrls.Contacts), request);
return(response);
#endregion processing
}
catch (Exception)
{
throw;
}
}
public async Task Create_ShouldReturnCreatedRecord()
{
// Arrange
await AuthenticationAsync();
// Act
var testContact =
new CreateContactRequest
{
FirstName = "Integration",
LastName = "Test",
CompanyName = "IntegrationTest"
};
var response
= await httpClient
.PostAsJsonAsync(
APIRoutes.ContactControllerRoutes.Create,
testContact);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.Created);
var returnedContactResponse = await response.Content.ReadAsAsync <ContactResponse>();
returnedContactResponse.FirstName.Should().Be(testContact.FirstName);
returnedContactResponse.LastName.Should().Be(testContact.LastName);
returnedContactResponse.CompanyName.Should().Be(testContact.CompanyName);
}
public async Task CreateContact_UnsuccessfulRequest_ShouldThrowContactApiException()
{
// Arrange
var firstName = Guid.NewGuid().ToString();
var lastName = Guid.NewGuid().ToString();
var createContactRequest = new CreateContactRequest(firstName, lastName);
var expectedResponse = new HttpResponseMessage
{
StatusCode = HttpStatusCode.BadRequest,
RequestMessage = new HttpRequestMessage
{
RequestUri = new Uri("http://www.mock-web-address.com"),
},
};
var contactApi = this.fixture.GetContactApi(expectedResponse);
// Act
Func <Task> act = async() => await contactApi.CreateContactAsync(createContactRequest);
// Assert
await act.Should().ThrowAsync <FactroApiException>();
}
public Contact CreateNewContact(CreateContactRequest contact)
{
var metaData = new Metadata();
var result = _contactClient.CreateContact(contact);
return(result.Contact);
}
public async Task CreateContactAsync_ValidContact_ShouldStoreContact()
{
// Arrange
await this.fixture.ClearFactroInstanceAsync();
var contactApi = this.fixture.GetService <IContactApi>();
var firstName = Guid.NewGuid().ToString();
var lastName = Guid.NewGuid().ToString();
var description = $"{BaseTestFixture.TestPrefix}{Guid.NewGuid().ToString()}";
var createContactRequest = new CreateContactRequest(firstName, lastName)
{
Description = description,
};
var createContactResponse = default(CreateContactResponse);
// Act
Func <Task> act = async() => createContactResponse = await contactApi.CreateContactAsync(createContactRequest);
// Assert
await act.Should().NotThrowAsync();
using (new AssertionScope())
{
var contacts = (await contactApi.GetContactsAsync())
.Where(x => x.Description.StartsWith(BaseTestFixture.TestPrefix)).ToList();
contacts.Should().ContainEquivalentOf(createContactResponse);
}
await this.fixture.ClearFactroInstanceAsync();
}
public async Task CreateContact_ValidRequest_ShouldReturnCreatedContact()
{
// Arrange
var firstName = Guid.NewGuid().ToString();
var lastName = Guid.NewGuid().ToString();
var createContactRequest = new CreateContactRequest(firstName, lastName);
var expectedContact = new CreateContactResponse
{
FirstName = firstName,
LastName = lastName,
};
var expectedResponseContent =
new StringContent(JsonConvert.SerializeObject(expectedContact, this.fixture.JsonSerializerSettings));
var expectedResponse = new HttpResponseMessage
{
Content = expectedResponseContent,
};
var contactApi = this.fixture.GetContactApi(expectedResponse);
var createContactResponse = default(CreateContactResponse);
// Act
Func <Task> act = async() => createContactResponse = await contactApi.CreateContactAsync(createContactRequest);
// Assert
await act.Should().NotThrowAsync();
createContactResponse.Should().BeEquivalentTo(expectedContact);
}
public void CreateContact()
{
moq::Mock <EssentialContactsService.EssentialContactsServiceClient> mockGrpcClient = new moq::Mock <EssentialContactsService.EssentialContactsServiceClient>(moq::MockBehavior.Strict);
CreateContactRequest request = new CreateContactRequest
{
ParentAsProjectName = gagr::ProjectName.FromProject("[PROJECT]"),
Contact = new Contact(),
};
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.CreateContact(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
EssentialContactsServiceClient client = new EssentialContactsServiceClientImpl(mockGrpcClient.Object, null);
Contact response = client.CreateContact(request.Parent, request.Contact);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public async Task <IActionResult> Create([FromBody] CreateContactRequest contactRequest)
{
var contact = new Contact
{
FirstName = contactRequest.FirstName,
LastName = contactRequest.LastName,
CompanyName = contactRequest.CompanyName,
OwnerUserId = HttpContext.GetCurrentUserId(),
};
await _contactService.CreateAsync(contact);
var baseUrl = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.ToUriComponent()}";
var createdLocationUri = $"{baseUrl}/{APIRoutes.ContactControllerRoutes.Get.Replace("{contactId}", contact.Id.ToString())}";
var contactResponse = new ContactResponse
{
Id = contact.Id,
FirstName = contact.FirstName,
LastName = contact.LastName,
CompanyName = contact.CompanyName,
};
await _redisCacheService
.DeleteCachedResponseAsync(
new string[]
{
HttpContext.Request.Path,
APIRoutes.ContactControllerRoutes.GetAll
});
return(Created(createdLocationUri, contactResponse));
}
private AddContactResponse Create(CreateContactRequest model)
{
AddContactResponse synergyResponse = new AddContactResponse();
Synergy.Common.Request.WebClient client = new Common.Request.WebClient();
var requestModel = model.ConvertToCreateContactRequest();
string requestData = GetJson(requestModel);
HttpWebResponse response = client.Post(JsonConvert.SerializeObject(requestModel), GetUrl(AgileCRMConstant.Contacts), 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);
synergyResponse.Status = Status.Success;
}
else
{
synergyResponse.Status = Status.Error;
var responseStream = response.GetResponseStream();
StreamReader streamReader = new StreamReader(responseStream);
string rawResponse = streamReader.ReadToEnd();
synergyResponse.Message = rawResponse;
}
return(synergyResponse);
}
public async stt::Task CreateContactRequestObjectAsync()
{
moq::Mock <EssentialContactsService.EssentialContactsServiceClient> mockGrpcClient = new moq::Mock <EssentialContactsService.EssentialContactsServiceClient>(moq::MockBehavior.Strict);
CreateContactRequest request = new CreateContactRequest
{
ParentAsProjectName = gagr::ProjectName.FromProject("[PROJECT]"),
Contact = new Contact(),
};
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.CreateContactAsync(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.CreateContactAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
Contact responseCancellationToken = await client.CreateContactAsync(request, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
public async void TestCreateWithTeam()
{
String accessToken = this.RandomString();
String teamId = this.RandomString();
Models.Contact contact = new Models.Contact();
contact.ContactData = new Models.ContactData();
contact.ContactData.Name = new Models.Fields.Name();
contact.ContactData.Name.FamilyName = this.RandomString();
CreateContactRequest req = new CreateContactRequest();
req.Contact = contact;
req.TeamId = teamId;
MockAPI <Contacts> mock = this.MockFor <Contacts>(
HttpMethod.Post,
"/api/v1/contacts.create",
m => m.WithContent(req.ToString())
.Respond("application/json", req.ToString())
);
APIResponse <ContactResponseBody> res = await mock.Instance.Create(accessToken, contact, teamId);
mock.Handler.VerifyNoOutstandingExpectation();
Assert.Equal(contact.ContactData.Name.FamilyName, res.Body.Contact.ContactData.Name.FamilyName);
}
public void Serialize_ValidInput_ShouldSerialize()
{
var createContactRequest = new CreateContactRequest();
var serializedPayload = _xmlService.Serialize(createContactRequest);
serializedPayload.Should().Be("<s:Envelope xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\" />");
}
public ActionResult AddContact(CreateContactRequest model)
{
model.UserId = SynergySecurity.GetCurrentUser();
model.Api = ApiTypes.AgileCrm;
model.Request = "Create New Contact";
contactApi.AddContact(model);
return(RedirectToAction("Contacts"));
}
public async Task <Contact> CreateNewContact(CreateContactRequest contact)
{
_logger.LogInformation("ContactResolver - CreateNewContact");
var metaData = new Metadata();
var result = await _contactClient.CreateContactAsync(contact, metaData);
return(result.Contact);
}
public void Deserialize_ValidInput_ShouldReturnDeserializedObject()
{
var serializedPayload = "<s:Envelope xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\" />";
var createContactRequest = new CreateContactRequest();
var deserializedPayload = _xmlService.DeserializeXml <CreateContactRequest>(serializedPayload);
deserializedPayload.Should().BeEquivalentTo(createContactRequest);
}
public void Arrange()
{
Setup();
ContactRequest = new CreateContactRequest(Moq.It.IsAny <string>(), Moq.It.IsAny <string>(),
Moq.It.IsAny <string>(), Moq.It.IsAny <string>(), Moq.It.IsAny <string>());
_validationResult = CreateContactRequestValidator.Validate(ContactRequest);
}
/// <summary>
/// Records a contact for a person syncronously
/// </summary>
/// <param name="personId">The ID of the person that was contacted</param>
/// <param name="parameters">Options for the contact</param>
/// <param name="cancellationToken">Token allowing the request to be cancelled</param>
/// <returns>The contact that was created</returns>
public Contact Create(int personId, CreateContactParameters parameters,
CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.IsNotNull(parameters, nameof(parameters));
var url = UrlProvider.GetV1ContactCreateUrl(personId);
var request = new CreateContactRequest(parameters);
return(PostJson <CreateContactResponse>(url, request, cancellationToken).Payload.Contact);
}
public static object ConvertToCreateContactRequest(this CreateContactRequest model)
{
return(new
{
star_value = model.StarValue,
lead_score = model.LeadScore,
tags = model.Tags ?? new string[] { },
properties = model.Property.ConvertToPropertyList(create: true)
});
}
public async Task <IActionResult> CreateContact(
[FromBody] CreateContactRequest createContactRequest)
{
_logger.LogInformation("Received Create Contact Request");
var contactResponse = await _mediator.Send(createContactRequest);
return(CreatedAtRoute("CreateContact",
contactResponse));
}
public async Task <ContactBoolResponse> InviteUser(CreateContactRequest createContactRequest)
{
using (var request = new HttpRequestMessage(HttpMethod.Post, $"/api/v1/contacts"))
{
var response =
await PostPutRequestWithResponse <CreateContactRequest, ContactBoolResponse>(request,
createContactRequest);
return(response);
}
}
private Contact MapToContactFrom(CreateContactRequest request)
{
return(new Contact
{
FirstName = request.FirstName,
LastName = request.LastName,
PhoneNumber = request.PhoneNumber,
Address = request.Address,
City = request.City,
State = request.State,
Zip = request.Zip,
});
}
public static Domain.Contact ToContact(this CreateContactRequest contactRequest)
{
return(new Domain.Contact
{
ContactId = Guid.NewGuid(),
ContactType = Domain.ContactType.Contact,
FirstName = contactRequest.FirstName,
LastName = contactRequest.LastName,
Title = contactRequest.Title,
Company = contactRequest.Company,
Description = contactRequest.Description
});
}
private string UpdateCustomerRecord(JToken amCustomers_Result, string suiteConstactId, string logId)
{
try
{
if (amCustomers_Result != null && suiteConstactId != null)
{
var suiteWrapper = new SuiteWrapper();
suitesessionId = suiteWrapper.Login().GetAwaiter().GetResult();
var contactrequest = new CreateContactRequest
{
Email = Convert.ToString(amCustomers_Result.SelectToken("preferred_email")),
Phone = Convert.ToString(amCustomers_Result.SelectToken("phone_number")),
FirstName = Convert.ToString(amCustomers_Result.SelectToken("given_name")),
LastName = Convert.ToString(amCustomers_Result.SelectToken("family_name")),
Salutation = Convert.ToString(amCustomers_Result.SelectToken("title")),
Fax = Convert.ToString(amCustomers_Result.SelectToken("fax_number")),
Comments = Convert.ToString(amCustomers_Result.SelectToken("notes")),
ContactType = "Individual",
CompanyName = Convert.ToString(amCustomers_Result.SelectToken("company_name")),
AMCustomerId = Convert.ToString(amCustomers_Result.SelectToken("row_id")),
Approvalestatus = "Pending_Approval",
Id = suiteConstactId
};
var request = new InsertRequest
{
SessionId = suitesessionId,
ModuleName = "Contacts",
Entity = contactrequest
};
var resp = suiteWrapper.Update(request).GetAwaiter().GetResult();
common.InsertSuiteAmIntegrationLogDetail(new CreateTraceLogRequest()
{
Description = "Updated Customer RecordID :" + resp.Id, Name = "InsertSuiteContact", Entity_c = "Customer"
}, logId);
SuiteWrapper.WriteTraceLog("InsertSuiteContact", "Updated Customer RecordID :" + resp.Id);
return(resp.Id);
}
}
catch (Exception ex)
{
common.InsertSuiteAmIntegrationLogDetail(new CreateTraceLogRequest()
{
Description = "Error : " + ex.Message, Name = "InsertSuiteContact", Entity_c = "Customer"
}, logId);
SuiteWrapper.WriteTraceLog("InsertSuiteContact", "Error : " + ex.Message);
}
return("");
}
public async Task <CreateContactResponse> CreateTestContactAsync(IContactApi contactApi)
{
var firstName = Guid.NewGuid().ToString();
var lastName = Guid.NewGuid().ToString();
var description = $"{TestPrefix}{Guid.NewGuid().ToString()}";
var createContactRequest = new CreateContactRequest(firstName, lastName)
{
Description = description,
};
var createContactResponse = await contactApi.CreateContactAsync(createContactRequest);
return(createContactResponse);
}
/// <summary>Snippet for CreateContact</summary>
public void CreateContactRequestObject()
{
// Snippet: CreateContact(CreateContactRequest, CallSettings)
// Create client
EssentialContactsServiceClient essentialContactsServiceClient = EssentialContactsServiceClient.Create();
// Initialize request argument(s)
CreateContactRequest request = new CreateContactRequest
{
ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
Contact = new Contact(),
};
// Make the request
Contact response = essentialContactsServiceClient.CreateContact(request);
// End snippet
}
public async Task CreateContactAsync_NullLastName_ShouldThrowArgumentNullException()
{
// Arrange
var firstName = Guid.NewGuid().ToString();
var createContactRequest = new CreateContactRequest(firstName, lastName: null);
var contactApi = this.fixture.GetContactApi();
// Act
Func <Task> act = async() => await contactApi.CreateContactAsync(createContactRequest);
// Assert
await act.Should().ThrowAsync <ArgumentNullException>();
}
public void Arrange()
{
Setup();
MappingBootstrapper.Initialize();
var contact = new ContactBoolResponse(true);
Mediator.Setup(q => q.Send(Moq.It.IsAny <CreateContactRequest>(), Moq.It.IsAny <CancellationToken>()))
.Returns(Task.FromResult((contact)));
var contactRequest = new CreateContactRequest(Moq.It.IsAny <string>(), Moq.It.IsAny <string>(),
Moq.It.IsAny <string>(), Moq.It.IsAny <string>(), Moq.It.IsAny <string>());
_result = ContactController.CreateContact(contactRequest).Result;
}
public void PushbulletCreateContactTest()
{
try
{
CreateContactRequest request = new CreateContactRequest()
{
Name = "Some Person",
Email = "*****@*****.**"
};
var result = Client.CreateNewContact(request);
Assert.IsNotNull(result);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
