public void UpdateCompleteContact()
{
var contact = GetMinimalContact();
var proxy = new ContactProxy();
var insertResponse = proxy.InsertContact(contact);
Assert.IsTrue(insertResponse.IsSuccessfull);
Assert.IsTrue(insertResponse.DataObject.InsertedContactId > 0);
var insertedContact = proxy.GetContact(insertResponse.DataObject.InsertedContactId);
insertedContact.DataObject.GivenName = "Jack";
insertedContact.DataObject.PostalAddress.City = "Potts Point";
var tags = new List <string>();
tags.Add("Banana");
tags.Add("Pear");
insertedContact.DataObject.Tags = tags;
var updateResponse = proxy.UpdateContact(insertedContact.DataObject, insertResponse.DataObject.InsertedContactId);
Assert.IsTrue(updateResponse.IsSuccessfull);
//System.Threading.Thread.Sleep(1000);
var updatedContact = proxy.GetContact(updateResponse.DataObject.UpdatedContactId);
Assert.AreEqual(insertedContact.DataObject.GivenName, updatedContact.DataObject.GivenName);
Assert.IsNotNull(updatedContact.DataObject.PostalAddress);
Assert.AreEqual(insertedContact.DataObject.PostalAddress.City, updatedContact.DataObject.PostalAddress.City);
}
public int GetOrCreateContact(string firstName, string lastName, string email)
{
var proxy = new ContactProxy();
var searchProxy = new ContactsProxy();
var companyProxy = new CompanyProxy();
var response = searchProxy.GetContacts(givenName: firstName, familyName: lastName);
if (response.IsSuccessfull && response.DataObject.Contacts.Any())
{
return(response.DataObject.Contacts[0].Id.GetValueOrDefault());
}
var contact = new Contact()
{
GivenName = firstName,
FamilyName = lastName,
EmailAddress = email,
};
var result = proxy.InsertContact(contact);
Assert.True(result.IsSuccessfull, "Failed to add customer contact test data.");
return(result.DataObject.InsertedContactId);
}
public void CanMarkAContactAsAContractor()
{
CrudProxy proxy = new ContactProxy();
ContactDto contact = GetContact1();
proxy.Insert(contact);
var fromDb = (ContactDto)proxy.GetByUid(contact.Uid);
Assert.IsFalse(((ContactType)fromDb.ContactType).HasFlag(ContactType.Contractor), "Shouldn't be flagged a contactor.");
var contactTypeFlag = ContactType.Contractor | ContactType.Supplier;
contact.ContactType = (int)contactTypeFlag;
proxy.Update(contact);
fromDb = (ContactDto)proxy.GetByUid(contact.Uid);
Assert.AreEqual((int)contactTypeFlag, fromDb.ContactType, "Incorrect contact type.");
var contactType = (ContactType)fromDb.ContactType;
Assert.IsTrue(contactType.HasFlag(ContactType.Contractor), "IsContractor should be true.");
Assert.IsTrue(contactType.HasFlag(ContactType.Supplier), "IsSupplier should be true.");
Assert.IsFalse(contactType.HasFlag(ContactType.Customer), "IsCustomer should be false.");
}
public void ShouldBeAbleToPutToApiWithXml()
{
var contactHelper = new ContactHelper(false);
var contact = contactHelper.GetMinimalContact();
contact.GivenName = "SerializationTests";
contact.FamilyName = "PutToApiWithXml";
contact.EmailAddress = "*****@*****.**";
var proxy = new ContactProxy {
ContentType = RequestContentType.ApplicationXml
};
var insertResponse = proxy.InsertContact(contact);
Assert.True(insertResponse.DataObject.InsertedContactId > 0);
var insertedContact = proxy.GetContact(insertResponse.DataObject.InsertedContactId);
Assert.True(insertedContact.IsSuccessfull && insertedContact.DataObject != null);
insertedContact.DataObject.GivenName = "NewNameWithXml";
var updateResult = proxy.UpdateContact(insertedContact.DataObject, insertedContact.DataObject.Id.GetValueOrDefault());
Assert.True(updateResult.IsSuccessfull);
var updatedContact = proxy.GetContact(updateResult.DataObject.UpdatedContactId);
Assert.True(updatedContact.IsSuccessfull);
Assert.Equal("NewNameWithXml", updatedContact.DataObject.GivenName);
}
public void ShouldUpdateContactAndAddNewCompanyAndContactManager()
{
var contactProxy = new ContactProxy();
var contactAggregateProxy = new ContactAggregateProxy();
var contact = GetContact();
var contactResponse = contactProxy.InsertContact(contact);
Assert.IsTrue(contactResponse.IsSuccessfull);
var contactAggregate = GetNewContactAggregate();
var contactAggregateResponse = contactAggregateProxy.UpdateContactAggregate(contactAggregate, contactResponse.DataObject.InsertedContactId);
Assert.IsTrue(contactAggregateResponse.IsSuccessfull, "Failed to update existing contact and add new company and contact manager");
Assert.IsNotNull(contactAggregateResponse.DataObject);
Assert.AreEqual(contactResponse.DataObject.InsertedContactId, contactAggregateResponse.DataObject.UpdatedContactId);
Assert.IsTrue(contactAggregateResponse.DataObject.CompanyId > 0, "Invalid CompanyId returned from UpdateContactAggregate when inserting new company");
Assert.IsTrue(contactAggregateResponse.DataObject.CompanyLastUpdatedId.Length > 0, "Invalid CompanyLastUpdatedId returned from UpdateContactAggregate when inserting new company");
Assert.IsTrue(contactAggregateResponse.DataObject.ContactManagerId > 0, "Invalid ContactManagerId returned from UpdateContactAggregate when inserting new contact manager");
Assert.IsTrue(contactAggregateResponse.DataObject.ContactManagerLastUpdatedId.Length > 0, "Invalid ContactManagerLastUpdatedId returned from UpdateContactAggregate when inserting new contact manager");
var updatedContact = contactProxy.GetContact(contactResponse.DataObject.InsertedContactId);
AssertUpdatedContact(contactAggregate, updatedContact);
var insertedAggregate =
contactAggregateProxy.GetContactAggregate(contactResponse.DataObject.InsertedContactId);
Assert.IsTrue(insertedAggregate.IsSuccessfull);
Assert.IsNotNull(insertedAggregate.DataObject);
Assert.IsNotNull(insertedAggregate.DataObject.Company, "New company not associated with existing contact");
Assert.IsNotNull(insertedAggregate.DataObject.ContactManager, "New contact manager not associated with existing contact");
Assert.AreEqual(contactAggregate.Company.Name, insertedAggregate.DataObject.Company.Name);
Assert.AreEqual(contactAggregate.ContactManager.GivenName, insertedAggregate.DataObject.ContactManager.GivenName);
}
public void IndexedContactShouldMatchEntityData()
{
var contactInfo = _searchHelper.CreateContact();
Thread.Sleep(5000); // Need to wait for entities to be indexed
var searchProxy = new SearchProxy();
var contact = new ContactProxy().GetContact(contactInfo.ContactId).DataObject;
var searchResults = searchProxy.Search(contact.EmailAddress, SearchScope.Contacts, 1, 10);
Assert.NotNull(searchResults.DataObject);
Assert.True(searchResults.DataObject.Contacts.Count > 0);
var indexedContact = searchResults.DataObject.Contacts.First(x => ReplaceEm(x.ContactEmail) == contact.EmailAddress);
Assert.NotNull(indexedContact);
Assert.Equal(contact.GivenName + " " + contact.FamilyName, ReplaceEm(indexedContact.Name));
Assert.Equal(contact.MobilePhone, indexedContact.MobilePhone);
Assert.Equal(contact.PrimaryPhone, indexedContact.MainPhone);
Assert.Equal(contact.Id, indexedContact.Id);
Assert.Equal("Contact", indexedContact.EntityType);
Assert.Equal(contact.CompanyId ?? 0, indexedContact.CompanyId);
Assert.Equal(contact.TwitterId, indexedContact.TwitterId);
}
public void ShouldNotUpdateContactManagerWhenContactLastUpdatedIdIncorrect()
{
var contactProxy = new ContactProxy();
var contactAggregateProxy = new ContactAggregateProxy();
var contactAggregate = GetNewContactAggregate();
var contactManager = GetContact();
var contactManagerResponse = contactProxy.InsertContact(contactManager);
var contact = GetContact();
var contactResponse = contactProxy.InsertContact(contact);
contactAggregate.Id = contactResponse.DataObject.InsertedContactId;
contactAggregate.LastUpdatedId = contactResponse.DataObject.LastUpdatedId.ToLower();
contactAggregate.ContactManager.Id = contactManagerResponse.DataObject.InsertedContactId;
contactAggregate.Company.LastUpdatedId = contactManagerResponse.DataObject.LastUpdatedId;
var aggregateResponse = contactAggregateProxy.UpdateContactAggregate(contactAggregate, contactResponse.DataObject.InsertedContactId);
Assert.IsFalse(aggregateResponse.IsSuccessfull);
Assert.AreEqual(HttpStatusCode.BadRequest, aggregateResponse.StatusCode);
Assert.AreEqual("\"Record to be updated has changed since last read.\"", aggregateResponse.RawResponse);
var updatedContact = contactProxy.GetContact(contactManagerResponse.DataObject.InsertedContactId);
Assert.AreEqual(contactManagerResponse.DataObject.LastUpdatedId, updatedContact.DataObject.LastUpdatedId);
}
public void ShouldAddNewContactWithNewCompanyAndContactManager()
{
var contactAggregateProxy = new ContactAggregateProxy();
var contactProxy = new ContactProxy();
var companyProxy = new CompanyProxy();
var contactAggregate = GetNewContactAggregate();
var Response = contactAggregateProxy.InsertContactAggregate(contactAggregate);
Assert.IsTrue(Response.IsSuccessfull, "Contact aggregate insert failed.");
Assert.IsNotNull(Response.DataObject);
Assert.IsTrue(Response.DataObject.InsertedContactId > 0, "Invalid InsertedContactId returned from InsertContactAggregate");
Assert.IsTrue(Response.DataObject.LastUpdatedId.Length > 0, "Invalid LastUpdatedId returned");
Assert.IsTrue(Response.DataObject.LastModified > DateTime.UtcNow.AddMinutes(-5), "Invalid LastModified returned");
Assert.IsTrue(Response.DataObject.CompanyId > 0, "Invalid CompanyId returned from InsertContactAggregate when inserting new company");
Assert.IsTrue(Response.DataObject.CompanyLastUpdatedId.Length > 0, "Invalid CompanyLastUpdatedId returned from InsertContactAggregate when inserting new company");
Assert.IsTrue(Response.DataObject.ContactManagerId > 0, "Invalid ContactManagerId returned from InsertContactAggregate when inserting new contact manager");
Assert.IsTrue(Response.DataObject.ContactManagerLastUpdatedId.Length > 0, "Invalid ContactManagerLastUpdatedId returned from InsertContactAggregate when inserting new contact manager");
var contactResponse = contactProxy.GetContact(Response.DataObject.InsertedContactId);
Assert.IsTrue(contactResponse.IsSuccessfull, "Contact not found");
Assert.IsNotNull(contactResponse.DataObject);
Assert.IsNotNull(contactResponse.DataObject.CompanyId);
Assert.IsNotNull(contactResponse.DataObject.ContactManagerId);
var contactManagerResponse = contactProxy.GetContact(contactResponse.DataObject.ContactManagerId.Value);
Assert.IsTrue(contactManagerResponse.IsSuccessfull, "Contact manager not found");
Assert.AreEqual(contactAggregate.ContactManager.FamilyName, contactManagerResponse.DataObject.FamilyName);
var companyResponse = companyProxy.GetCompany(contactResponse.DataObject.CompanyId.Value);
Assert.IsTrue(companyResponse.IsSuccessfull, "Company not found");
Assert.AreEqual(contactAggregate.Company.Name, companyResponse.DataObject.Name);
}
public void IndexedContactShouldMatchEntityData()
{
var searchProxy = new SearchProxy();
var contactHelper = new ContactHelper();
var contactResponse = contactHelper.AddContact();
Thread.Sleep(2000);
var contact = new ContactProxy().GetContact(contactResponse.InsertedContactId).DataObject;
var searchResults = searchProxy.Search(contact.EmailAddress, SearchScope.Contacts, 1, 10);
Assert.IsNotNull(searchResults.DataObject);
Assert.IsTrue(searchResults.DataObject.Contacts.Count > 0);
var indexedContact = searchResults.DataObject.Contacts.First(x => ReplaceEm(x.ContactEmail) == contact.EmailAddress);
Assert.IsNotNull(indexedContact);
Assert.AreEqual(contact.GivenName + " " + contact.FamilyName, ReplaceEm(indexedContact.Name));
Assert.AreEqual(contact.MobilePhone, indexedContact.MobilePhone);
Assert.AreEqual(contact.PrimaryPhone, indexedContact.MainPhone);
Assert.AreEqual(contact.Id, indexedContact.Id);
Assert.AreEqual("Contact", indexedContact.EntityType);
Assert.AreEqual(contact.CompanyId ?? 0, indexedContact.CompanyId);
Assert.AreEqual(contact.TwitterId, indexedContact.TwitterId);
}
public void UpdateContactOrganizationDetails()
{
CrudProxy proxy = new ContactProxy();
ContactDto dto1 = this.GetContact1();
proxy.Insert(dto1);
Assert.IsTrue(dto1.Uid > 0, "Uid must be > 0 after save.");
int tempContactUid = dto1.Uid;
string lastUpdatedUid = dto1.LastUpdatedUid;
dto1 = this.GetContact2();
dto1.OrganisationName = "Updated Organization Name";
dto1.OrganisationAbn = "U1234567";
dto1.OrganisationPosition = "Updated Organization Position";
dto1.OrganisationWebsite = "www.updatedorg.com";
dto1.Uid = tempContactUid;
dto1.LastUpdatedUid = lastUpdatedUid;
proxy.Update(dto1);
var tmpDto = (ContactDto)proxy.GetByUid(dto1.Uid);
AssertEqual(dto1, tmpDto);
}
public InsertContactResult AddContact()
{
var contact = GetCompleteContact();
var proxy = new ContactProxy();
var response = proxy.InsertContact(contact);
return(response.DataObject);
}
public void InsertContactWithBankDetails()
{
CrudProxy proxy = new ContactProxy();
ContactDto dto1 = this.GetContact3();
proxy.Insert(dto1);
AssertEqual(dto1, (ContactDto)proxy.GetByUid(dto1.Uid));
}
public async Task GetContacts_ShouldReturnContacts()
{
var sut = new ContactProxy();
IList<Contact> actual = await sut.GetContacts();
Assert.That(actual, Is.Not.Null);
Assert.That(actual.Count, Is.EqualTo(30));
}
public void ShouldAddNewContactAndUpdateCompanyAndContactManager()
{
var contactAggregateProxy = new ContactAggregateProxy();
var contactProxy = new ContactProxy();
var companyProxy = new CompanyProxy();
var companyDetail = GetCompany();
var companyResponse = companyProxy.InsertCompany(companyDetail);
var contactManager = GetContact();
var contactManagerResponse = contactProxy.InsertContact(contactManager);
var contactAggregate = GetNewContactAggregate();
contactAggregate.Company.Id = companyResponse.DataObject.InsertedCompanyId;
contactAggregate.Company.LastUpdatedId = companyResponse.DataObject.LastUpdatedId;
contactAggregate.ContactManager.Id = contactManagerResponse.DataObject.InsertedContactId;
contactAggregate.ContactManager.LastUpdatedId = contactManagerResponse.DataObject.LastUpdatedId;
var contactAggregateResponse = contactAggregateProxy.InsertContactAggregate(contactAggregate);
Assert.IsTrue(contactAggregateResponse.IsSuccessfull, "Contact aggregate with new contact and updated company and contact manager failed");
Assert.IsNotNull(contactAggregateResponse.DataObject);
Assert.IsTrue(contactAggregateResponse.DataObject.CompanyId > 0, "Invalid CompanyId returned from InsertContactAggregate when updating company");
Assert.IsTrue(contactAggregateResponse.DataObject.CompanyLastUpdatedId.Length > 0, "Invalid CompanyLastUpdatedId returned from InsertContactAggregate when updating company");
Assert.IsTrue(contactAggregateResponse.DataObject.ContactManagerId > 0, "Invalid ContactManagerId returned from InsertContactAggregate when updating contact manager");
Assert.IsTrue(contactAggregateResponse.DataObject.ContactManagerLastUpdatedId.Length > 0, "Invalid ContactManagerLastUpdatedId returned from InsertContactAggregate when updating contact manager");
var dbContactAggregate =
contactAggregateProxy.GetContactAggregate(contactAggregateResponse.DataObject.InsertedContactId);
Assert.IsTrue(dbContactAggregate.IsSuccessfull);
Assert.IsNotNull(dbContactAggregate.DataObject);
Assert.IsNotNull(dbContactAggregate.DataObject.ContactManager.Id);
Assert.IsNotNull(dbContactAggregate.DataObject.Company.Id);
Assert.AreEqual(companyResponse.DataObject.InsertedCompanyId, dbContactAggregate.DataObject.Company.Id.Value, "Existing company not attached to contact aggregate");
Assert.AreEqual(contactManagerResponse.DataObject.InsertedContactId, dbContactAggregate.DataObject.ContactManager.Id.Value, "Existing contact (manager) not attached to contact aggregate");
var dbContactManager = contactProxy.GetContact(dbContactAggregate.DataObject.ContactManager.Id.Value);
Assert.IsTrue(dbContactManager.IsSuccessfull);
Assert.IsNotNull(dbContactManager.DataObject);
AssertContactManager(dbContactAggregate.DataObject.ContactManager, dbContactManager.DataObject);
Assert.AreEqual(dbContactAggregate.DataObject.ContactManager.LastUpdatedId,
dbContactManager.DataObject.LastUpdatedId, "LastUpdatedId not updated for contact manager");
var dbCompany = companyProxy.GetCompany(dbContactAggregate.DataObject.Company.Id.Value);
Assert.IsTrue(dbCompany.IsSuccessfull);
Assert.IsNotNull(dbCompany.DataObject);
AssertCompany(dbContactAggregate.DataObject.Company, dbCompany.DataObject);
Assert.AreEqual(dbContactAggregate.DataObject.Company.LastUpdatedId, dbCompany.DataObject.LastUpdatedId,
"LastUpdatedId not updated for company");
}
public void InsertUsingUnsupportedSalutation()
{
CrudProxy proxy = new ContactProxy();
ContactDto dto1 = this.GetContact1();
dto1.Salutation = "Sir";
// Should be ok, but won't be shown on UI.
proxy.Insert(dto1);
}
public void InvalidABN()
{
CrudProxy proxy = new ContactProxy();
ContactDto dto1 = this.GetContactInvalidAbn();
proxy.Insert(dto1);
ContactDto fromDB = (ContactDto)proxy.GetByUid(dto1.Uid);
Assert.AreEqual("ABC123", fromDB.OrganisationAbn, "Incorrect org. abn.");
}
public void ModifyingContactsIsBooleanFieldsShouldNotAffectOtherIsBooleanFields()
{
var contactsProxy = new ContactsProxy();
//Find Test contact to obtain their Id.
var contactsResponse = AssertContactProxy(contactsProxy, givenName: "carl", familyName: "o'neil", contactId: "GLD879");
Assert.IsTrue(contactsResponse.DataObject.Contacts.Count >= 1, "Incorrect number of contacts found.");
var proxy = new ContactProxy();
var testId = contactsResponse.DataObject.Contacts[0].Id;
var response = proxy.GetContact(testId.Value);
Assert.IsNotNull(response);
Assert.IsTrue(response.IsSuccessfull);
Assert.IsNotNull(response.DataObject);
// Now Modify the IsCustomer, IsContractor, IsSupplier, Is... fields and ensure setting one does not clear the other
var testContact = response.DataObject;
testContact.IsContractor = true;
testContact.IsCustomer = true;
testContact.IsPartner = true;
testContact.IsSupplier = true;
var updateResponse = proxy.UpdateContact(testContact, testContact.Id.Value);
Assert.IsNotNull(updateResponse);
Assert.IsTrue(updateResponse.IsSuccessfull);
var updatedResponse1 = proxy.GetContact(testContact.Id.Value);
Assert.IsTrue(updatedResponse1.IsSuccessfull);
Assert.AreEqual(testContact.IsContractor, updatedResponse1.DataObject.IsContractor);
Assert.AreEqual(testContact.IsCustomer, updatedResponse1.DataObject.IsCustomer);
Assert.AreEqual(testContact.IsPartner, updatedResponse1.DataObject.IsPartner);
Assert.AreEqual(testContact.IsSupplier, updatedResponse1.DataObject.IsSupplier);
testContact.LastUpdatedId = updateResponse.DataObject.LastUpdatedId;
testContact.IsSupplier = false;
testContact.IsPartner = false;
var updateResponse2 = proxy.UpdateContact(testContact, testContact.Id.Value);
Assert.IsNotNull(updateResponse2);
Assert.IsTrue(updateResponse2.IsSuccessfull);
var updatedResponse2 = proxy.GetContact(testContact.Id.Value);
Assert.IsTrue(updatedResponse2.IsSuccessfull);
Assert.AreEqual(testContact.IsContractor, updatedResponse2.DataObject.IsContractor);
Assert.AreEqual(testContact.IsCustomer, updatedResponse2.DataObject.IsCustomer);
Assert.AreEqual(testContact.IsPartner, updatedResponse2.DataObject.IsPartner);
Assert.AreEqual(testContact.IsSupplier, updatedResponse2.DataObject.IsSupplier);
}
public void InsertWithDefaultSaleDiscount()
{
CrudProxy proxy = new ContactProxy();
ContactDto contact = GetContact1();
contact.DefaultSaleDiscount = 10.50M;
proxy.Insert(contact);
ContactDto fromDb = (ContactDto)proxy.GetByUid(contact.Uid);
AssertEqual(contact, fromDb);
}
public void ShouldNotModifyExistingContactFieldsNotContainedInAggregateModel()
{
var contactProxy = new ContactProxy();
var contactAggregateProxy = new ContactAggregateProxy();
var contactAggregate = GetNewContactAggregate();
var contact = GetCompleteContact();
var contactResponse = contactProxy.InsertContact(contact);
contactAggregate.Id = contactResponse.DataObject.InsertedContactId;
contactAggregate.LastUpdatedId = contactResponse.DataObject.LastUpdatedId;
var aggregateResponse = contactAggregateProxy.UpdateContactAggregate(contactAggregate, contactResponse.DataObject.InsertedContactId);
Assert.IsTrue(aggregateResponse.IsSuccessfull);
var updatedContactResponse = contactProxy.GetContact(contactResponse.DataObject.InsertedContactId);
Assert.IsTrue(updatedContactResponse.IsSuccessfull);
Assert.IsNotNull(updatedContactResponse.DataObject);
var updatedContact = updatedContactResponse.DataObject;
Assert.AreEqual(contact.AutoSendStatement, updatedContact.AutoSendStatement);
Assert.AreEqual(contact.BpayDetails.BillerCode, updatedContact.BpayDetails.BillerCode);
Assert.AreEqual(contact.BpayDetails.CRN, updatedContact.BpayDetails.CRN);
Assert.AreEqual(contact.ChequeDetails.AcceptCheque, updatedContact.ChequeDetails.AcceptCheque);
Assert.AreEqual(contact.ChequeDetails.ChequePayableTo, updatedContact.ChequeDetails.ChequePayableTo);
Assert.AreEqual(contact.CustomField1, updatedContact.CustomField1);
Assert.AreEqual(contact.CustomField2, updatedContact.CustomField2);
Assert.AreEqual(contact.DefaultPurchaseDiscount, updatedContact.DefaultPurchaseDiscount);
Assert.AreEqual(contact.DefaultSaleDiscount, updatedContact.DefaultSaleDiscount);
Assert.AreEqual(contact.DirectDepositDetails.AcceptDirectDeposit, updatedContact.DirectDepositDetails.AcceptDirectDeposit);
Assert.AreEqual(contact.DirectDepositDetails.AccountBSB, updatedContact.DirectDepositDetails.AccountBSB);
Assert.AreEqual(contact.DirectDepositDetails.AccountName, updatedContact.DirectDepositDetails.AccountName);
Assert.AreEqual(contact.DirectDepositDetails.AccountNumber, updatedContact.DirectDepositDetails.AccountNumber);
Assert.AreEqual(contact.HomePhone, updatedContact.HomePhone);
Assert.AreEqual(contact.LinkedInProfile, updatedContact.LinkedInProfile);
Assert.AreEqual(contact.OtherAddress.City, updatedContact.OtherAddress.City);
Assert.AreEqual(contact.OtherAddress.Country, updatedContact.OtherAddress.Country);
Assert.AreEqual(contact.OtherAddress.Postcode, updatedContact.OtherAddress.Postcode);
Assert.AreEqual(contact.OtherAddress.State, updatedContact.OtherAddress.State);
Assert.AreEqual(contact.OtherAddress.Street, updatedContact.OtherAddress.Street);
Assert.AreEqual(contact.OtherPhone, updatedContact.OtherPhone);
Assert.AreEqual(contact.PurchaseTradingTerms.TradingTermsInterval, updatedContact.PurchaseTradingTerms.TradingTermsInterval);
Assert.AreEqual(contact.PurchaseTradingTerms.TradingTermsIntervalType, updatedContact.PurchaseTradingTerms.TradingTermsIntervalType);
Assert.AreEqual(contact.PurchaseTradingTerms.TradingTermsType, updatedContact.PurchaseTradingTerms.TradingTermsType);
Assert.AreEqual(contact.SaleTradingTerms.TradingTermsInterval, updatedContact.SaleTradingTerms.TradingTermsInterval);
Assert.AreEqual(contact.SaleTradingTerms.TradingTermsIntervalType, updatedContact.SaleTradingTerms.TradingTermsIntervalType);
Assert.AreEqual(contact.SaleTradingTerms.TradingTermsType, updatedContact.SaleTradingTerms.TradingTermsType);
Assert.AreEqual(contact.SkypeId, updatedContact.SkypeId);
Assert.AreEqual(contact.TwitterId, updatedContact.TwitterId);
Assert.AreEqual(contact.WebsiteUrl, updatedContact.WebsiteUrl);
}
public MasterViewController(IntPtr handle)
: base(handle)
{
Title = "Contacts";
if (UIDevice.CurrentDevice.UserInterfaceIdiom == UIUserInterfaceIdiom.Pad)
{
PreferredContentSize = new CGSize(320f, 600f);
ClearsSelectionOnViewWillAppear = false;
}
_contactProxy = new ContactProxy();
}
public void CanInsertAContractor()
{
CrudProxy proxy = new ContactProxy();
ContactDto contact = GetContact1();
contact.ContactType = (int)ContactType.Contractor;
proxy.Insert(contact);
var fromDb = (ContactDto)proxy.GetByUid(contact.Uid);
AssertEqual(contact, fromDb);
Assert.IsTrue(((ContactType)fromDb.ContactType).HasFlag(ContactType.Contractor), "Contractor flag should be set.");
}
public void InsertWithTags()
{
CrudProxy proxy = new ContactProxy();
ContactDto dto1 = this.GetContact4();
proxy.Insert(dto1);
Assert.IsTrue(dto1.Uid > 0, "Uid must be > 0 after save.");
ContactDto dto2 = (ContactDto)proxy.GetByUid(dto1.Uid);
AssertEqual(dto1, dto2, true);
}
private void AddCarl()
{
CrudProxy proxy = new ContactProxy();
ContactDto dto = new ContactDto();
dto.Salutation = "Mr.";
dto.GivenName = "Carl";
dto.FamilyName = "O'Neil";
dto.OrganisationName = "O'Neil Capital";
dto.ContactID = "GLD879";
dto.CustomField1 = "O'Neil";
proxy.Insert(dto);
Assert.IsTrue(dto.Uid > 0, "Incorrect uid post save.");
}
private void GetPrimarySupplierContact()
{
var contact = new Contact()
{
GivenName = "Peter",
FamilyName = "Baker",
EmailAddress = "*****@*****.**",
HomePhone = "0252113414"
};
var proxy = new ContactProxy();
var response = proxy.InsertContact(contact);
_primarySupplierId = response.DataObject.InsertedContactId;
}
public void InsertWithCustomField()
{
CrudProxy proxy = new ContactProxy();
ContactDto dto1 = this.GetContact1();
dto1.CustomField1 = "This is custom field 1";
dto1.CustomField2 = "This is custom field 2";
proxy.Insert(dto1);
Assert.IsTrue(dto1.Uid > 0, "Uid must be > 0 after insert.");
dto1 = (ContactDto)proxy.GetByUid(dto1.Uid);
Assert.AreEqual("This is custom field 1", dto1.CustomField1, "Incorrect custom field 1");
Assert.AreEqual("This is custom field 2", dto1.CustomField2, "Incorrect custom field 2");
}
public (Contact ContactDetail, int ContactId) CreateContact(int?companyId = null, string companyName = null)
{
var contactFake = new Faker <Contact>()
.RuleFor(c => c.CompanyId, companyId ?? CreateCompany(companyName).CompanyId)
.RuleFor(c => c.GivenName, (f, c) => f.Name.FirstName())
.RuleFor(c => c.FamilyName, (f, c) => f.Name.LastName())
.RuleFor(c => c.EmailAddress, (f, c) => f.Internet.Email(c.GivenName, c.FamilyName));
var proxy = new ContactProxy();
var contact = contactFake.Generate();
var result = proxy.InsertContact(contact);
Assert.True(result.IsSuccessfull, "Failed to add customer contact test data.");
return(contact, result.DataObject.InsertedContactId);
}
public void UpdateWithDefaultPurchaseDiscount()
{
CrudProxy proxy = new ContactProxy();
ContactDto contact = GetContact1();
contact.DefaultPurchaseDiscount = 15.75M;
proxy.Insert(contact);
contact.DefaultPurchaseDiscount = 14.75M;
proxy.Update(contact);
ContactDto fromDb = (ContactDto)proxy.GetByUid(contact.Uid);
AssertEqual(contact, fromDb);
}
public void InsertWithTwitterIdAndSkypeID()
{
CrudProxy proxy = new ContactProxy();
ContactDto dto1 = this.GetContact1();
dto1.TwitterId = "Contact1TwitterId";
dto1.SkypeId = "Contact1SkypeId";
proxy.Insert(dto1);
Assert.IsTrue(dto1.Uid > 0, "Uid must be > 0 after insert.");
dto1 = (ContactDto)proxy.GetByUid(dto1.Uid);
Assert.AreEqual("Contact1TwitterId", dto1.TwitterId, "Incorrect twitter ID");
Assert.AreEqual("Contact1SkypeId", dto1.SkypeId, "Incorrect skype ID");
}
public void InsertWithCustomFieldLongerThan50Chars()
{
CrudProxy proxy = new ContactProxy();
ContactDto dto1 = this.GetContact1();
dto1.CustomField1 = "This is custom field 1 This is custom field 1 This is custom field 1 This is custom field 1 This is custom field 1 This is custom field 1 This is custom field 1";
try
{
proxy.Insert(dto1);
throw new Exception("The expected exception is not thrown.");
}
catch (RestException rex)
{
Assert.AreEqual("The custom field 1 must not exceed 50 characters.", rex.Message, "Incorrect exception message.");
}
}
public void UpdateWithLinkedInPublicProfile()
{
CrudProxy proxy = new ContactProxy();
ContactDto dto1 = this.GetContact1();
dto1.LinkedInPublicProfile = "http://www.linkedin.com/pub/kasun-amarasinghe/5/984/b5b";
proxy.Insert(dto1);
Assert.IsTrue(dto1.Uid > 0, "Uid must be > 0 after insert.");
dto1.LinkedInPublicProfile = "http://www.linkedin.com/in/marclehmann";
proxy.Update(dto1);
dto1 = (ContactDto)proxy.GetByUid(dto1.Uid);
Assert.AreEqual("http://www.linkedin.com/in/marclehmann", dto1.LinkedInPublicProfile, "Incorrect LinkedIn Public Profile");
}
public void TradingTermsBackwardsCompatibility()
{
CrudProxy proxy = new ContactProxy();
ContactDto dto1 = this.GetContact1();
dto1.SaleTradingTermsPaymentDueInInterval = 14;
dto1.SaleTradingTermsPaymentDueInIntervalType = 1;
proxy.Insert(dto1);
Assert.IsTrue(dto1.Uid > 0, "Uid must be > 0 after insert.");
dto1 = (ContactDto)proxy.GetByUid(dto1.Uid);
Assert.AreEqual(1, dto1.SaleTradingTerms.Type, "Incorrect Sale Trading Terms Type");
Assert.AreEqual(14, dto1.SaleTradingTerms.Interval, "Incorrect Sale Trading Terms Interval");
Assert.AreEqual(1, dto1.SaleTradingTerms.IntervalType, "Incorrect Sale Trading Terms Interval Type");
}
public void ShouldBeAbleToPostToApiWithJson()
{
var contactHelper = new ContactHelper(false);
var contact = contactHelper.GetMinimalContact();
contact.GivenName = "SerializationTests";
contact.FamilyName = "PostToApiWithJson";
contact.EmailAddress = "*****@*****.**";
var proxy = new ContactProxy();
proxy.ContentType = RequestContentType.ApplicationJson;
var insertResponse = proxy.InsertContact(contact);
Assert.True(insertResponse.DataObject.InsertedContactId > 0);
}