public Contact GetContact(string contactEmail)
{
if (String.IsNullOrEmpty(contactEmail))
{
Logger.Error("Call to GetContact() when contactEmail was null.");
throw new ArgumentNullException("contactEmail");
}
try
{
List <stringValue> emailVals = new List <stringValue>();
emailVals.Add(new stringValue {
value = contactEmail, @operator = filterOperator.EqualTo, operatorSpecified = true
});
var filter = new contactFilter {
email = emailVals.ToArray()
};
var brontoContacts = wrapper.ReadContacts(filter, GetContactFieldIds());
if (brontoContacts != null && brontoContacts.Length > 0)
{
var brontoContact = brontoContacts[0];
var ct = new Contact()
{
Id = brontoContact.id,
Email = brontoContact.email,
SiteCode = this.siteCode
};
if (brontoContact.fields != null && brontoContact.fields.Length > 0)
{
foreach (contactField f in brontoContact.fields)
{
if (!ct.Fields.ContainsKey(GetContactFields()[f.fieldId]))
{
ct.Fields.Add(GetContactFields()[f.fieldId], f.content);
}
else
{
ct.Fields[GetContactFields()[f.fieldId]] = f.content;
}
}
}
ct.Status = (ContactStatusEnum)Enum.Parse(typeof(ContactStatusEnum), brontoContact.status, true);
Logger.Debug(String.Format("GetContact Function: Contact with email: '{0}' has status on Bronto: '{1}'", contactEmail, brontoContact.status));
return(ct);
}
else
{
Logger.Debug(String.Format("GetContact Function: Contact with email: '{0}' was not found on Bronto", contactEmail));
return(null);
}
}
catch (Exception e)
{
Logger.Error(e);
throw e;
}
}
/// <summary>
/// Reads contacts from bronto using a filter and the specified return fields and information
/// </summary>
/// <param name="filter">The filter to use when reading</param>
/// <param name="options">The fields and information to return. Use the extension methods on the readContacts class to specify options</param>
/// <returns>the list of contacts</returns>
public async Task <List <contactObject> > ReadAsync(contactFilter filter, readContacts options = null)
{
if (filter == null)
{
throw new ArgumentNullException("filter", "The filter must be specified. Alternatively call the Read() function");
}
using (BrontoSoapPortTypeClient client = BrontoSoapClient.Create(Timeout))
{
readContacts c = options ?? new readContacts();
c.filter = filter;
c.pageNumber = 1;
List <contactObject> list = new List <contactObject>();
readContactsResponse response = await client.readContactsAsync(session.SessionHeader, c);
contactObject[] result = response.@return;
if (result != null)
{
list.AddRange(result);
}
while (result != null && result.Length > 0)
{
c.pageNumber += 1;
response = await client.readContactsAsync(session.SessionHeader, c);
result = response.@return;
if (result != null)
{
list.AddRange(result);
}
}
return(list);
}
}
/// <summary>
/// Add or updates a list of contacts in Bronto
/// </summary>
/// <param name="contact">The contacts to add or update</param>
/// <returns>The result of the add or update operation <seealso cref="BrontoResult"/></returns>
public BrontoResult AddOrUpdateIncremental(IEnumerable <contactObject> contacts)
{
using (BrontoSoapPortTypeClient client = BrontoSoapClient.Create(Timeout))
{
foreach (contactObject contact in contacts)
{
var address = new stringValue {
value = contact.email
};
var emailAddressArray = new[] { address };
var filter = new contactFilter
{
email = emailAddressArray
};
var options = new readContacts()
{
includeLists = true,
includeListsSpecified = true
};
var readResults = Read(filter, options);
var existingContact = readResults.FirstOrDefault();
if (existingContact != null)
{
contact.listIds = contact.listIds.Concat(existingContact.listIds).ToArray();
}
}
writeResult response = client.addOrUpdateContacts(session.SessionHeader, contacts.ToArray());
return(BrontoResult.Create(response));
}
}
private contactFilter GetEmailContactFilter()
{
contactFilter filter = new contactFilter();
filter.email = new stringValue[]
{
new stringValue()
{
@operator = filterOperator.Contains,
operatorSpecified = true,
value = "example.com"
}
};
return(filter);
}
public void ReadAllContactsWithAllInfoAndFields()
{
Contacts contacts = new Contacts(Login);
StartTimer("Reading all contacts with @example.com in email");
contactFilter filter = GetEmailContactFilter();
List <contactObject> list = ReadContactsInternal(contacts, filter, Contacts.ReadOptions.IncludeAll().IncludeFields(fields));
Console.WriteLine(EndTimer().ToString());
Console.WriteLine("{0} contacts read", list.Count);
if (list.Count > 0)
{
WriteContactToConsole(list.First());
}
}
public void DeleteAllContacts()
{
Contacts contacts = new Contacts(Login);
StartTimer("Reading all contacts with @example.com in email");
contactFilter filter = new contactFilter();
filter.email = new stringValue[]
{
new stringValue()
{
@operator = filterOperator.Contains,
operatorSpecified = true,
value = "example.com"
}
};
List <contactObject> list = contacts.Read(filter);
Console.WriteLine(EndTimer().ToString());
Console.WriteLine("{0} contacts read", list.Count);
StartTimer("Deleting all contacts with @example.com in email");
BrontoResult result = contacts.Delete(list.Select(x => { return(new contactObject()
{
id = x.id
}); }));
if (result.HasErrors)
{
Console.WriteLine("Completed with errors");
foreach (BrontoResultItem brontoResultItem in result.Items.Where(x => x.IsError))
{
Console.WriteLine("{0}: ({1}) {2} (Is new: {3}. Is Error: {4}", brontoResultItem.Id,
brontoResultItem.ErrorCode, brontoResultItem.ErrorString, brontoResultItem.IsNew,
brontoResultItem.IsError);
}
}
else
{
Console.WriteLine("{0} contacts deleted", result.Items.Count);
}
}
public contactObject[] ReadContacts(contactFilter filter, string[] contactFieldIds)
{
return(api.readContacts(filter, false, false, contactFieldIds, 0, false, false, false, false, false, false, false, false, false, false));
}
public contactObject[] ReadContacts(contactFilter filter)
{
return(api.readContacts(new contactFilter(), false, false, null, 0, false, false, false, false, false, false, false, false, false, false));
}
public IEnumerable<IMetricsProvider> GetMetrics(int days)
{
///////////////////////////////////////////////////////////////////
//
// Instantiate the client
//
///////////////////////////////////////////////////////////////////
sessionHeader header = new sessionHeader();
BrontoSoapPortTypeClient client = new BrontoSoapPortTypeClient();
header.sessionId = client.login(ConfigurationManager.AppSettings[GetType().Name]);
///////////////////////////////////////////////////////////////////
//
// Retrieve the contact for which you need the metrics.
//
///////////////////////////////////////////////////////////////////
contactFilter cf = new contactFilter();
cf.id = new string[] { "4a8e4dc1-e38f-438b-b8b5-75e46799bc9c" };
readContacts rc = new readContacts();
rc.filter = cf;
contactObject[] co = client.readContacts(header, rc);
contactObject mycontact = co[0];
///////////////////////////////////////////////////////////////////
//
// Create a deliverFilter and read all deliverObjects
//
///////////////////////////////////////////////////////////////////
deliveryFilter df = new deliveryFilter();
df.deliveryType = new string[] { "normal","test","automated","split","transactional","triggered" };
readDeliveries rd = new readDeliveries();
rd.filter = df;
deliveryObject[] dos = client.readDeliveries(header, rd);
///////////////////////////////////////////////////////////////////
//
// Extract deliverObjects into ProviderMetrics
//
///////////////////////////////////////////////////////////////////
List<IMetricsProvider> list = new List<IMetricsProvider>();
try
{
foreach (deliveryObject doj in dos)
{
ProviderMetrics item = new ProviderMetrics();
//deliveryRecipientObject[] dro = doj.recipients;
// id can be contact id, list id or segment id
//dro[0].id
// if contactId, there are metrics by contact, but that doesn't tell the full story
/*
deliveryRecipientFilter drf = new deliveryRecipientFilter();
drf.deliveryId = doj.id;
readDeliveryRecipients rdr = new readDeliveryRecipients();
rdr.filter = drf;
deliveryRecipientStatObject[] drso = client.readDeliveryRecipients(header, rdr);
*/
// Once we receive the deliveryRecipientStatObject, we have to check
// if this object has click/send/bounce and store the contactId accordingly
item.Name = doj.messageId;
item.Bounces = (int)doj.numBounces;
item.Clicks = (int)doj.numClicks;
item.Opens = (int)doj.numOpens;
item.Sends = (int)doj.numSends;
// read unsubscribes
unsubscribeFilter uf = new unsubscribeFilter();
uf.deliveryId = doj.id;
readUnsubscribes ru = new readUnsubscribes();
ru.filter = uf;
ru.pageNumber = 1;
if (client.readUnsubscribes(header, ru) == null)
item.Unsubscribes = 0;
else
item.Unsubscribes = client.readUnsubscribes(header, ru).Length;
list.Add(item);
}
}
catch (Exception e)
{
MessageBox.Show(e.Message);
ProviderMetrics item = new ProviderMetrics();
item.Name = "null";
item.Bounces = 0;
item.Clicks = 0;
item.Opens = 0;
item.Sends = 0;
item.Unsubscribes = 0;
list.Add(item);
}
return list;
}
private List <contactObject> ReadContactsInternal(Contacts contacts, contactFilter filter, readContacts options)
{
return(contacts.Read(filter, options));
}
public void AddContactWithListReference()
{
MailLists lists = new MailLists(Login);
Contacts contacts = new Contacts(Login);
List <mailListObject> mailLists = new List <mailListObject>()
{
new mailListObject()
{
name = "Test list A" + DateTime.Now,
label = "Test list A",
status = Bronto.API.ListStatus.Active
},
new mailListObject()
{
name = "Test list B" + DateTime.Now,
label = "Test list B",
status = Bronto.API.ListStatus.Active
}
};
BrontoResult listResult = lists.Add(mailLists);
Assert.IsFalse(listResult.HasErrors, "The two test lists was not created");
mailLists[0].id = listResult.Items[0].Id;
mailLists[1].id = listResult.Items[1].Id;
contactObject contact = GetTestContacts(1, new Random()).First();
contact.listIds = listResult.Items.Select(x => x.Id).ToArray();
BrontoResult contactResult = contacts.Add(contact);
Assert.IsFalse(contactResult.HasErrors, "The contact was not created");
contactFilter filter = new contactFilter();
filter.listId = listResult.Items.Select(x => x.Id).ToArray();
filter.type = filterType.OR;
filter.typeSpecified = true;
List <contactObject> listContacts = contacts.Read(filter, Contacts.ReadOptions.IncludeAll().IncludeFields(fields));
Assert.IsTrue(listContacts.Count == 1);
contact.listIds = new string[] { listResult.Items.Select(x => x.Id).First() };
contactResult = contacts.AddOrUpdate(contact);
contact.id = contactResult.Items[0].Id;
Assert.IsFalse(contactResult.HasErrors, "The contact was not updated");
Assert.IsTrue(contactResult.Items.Count(x => x.IsNew) == 0, "The contact was created instead of being updated");
filter = new contactFilter();
filter.listId = new string[] { listResult.Items.Select(x => x.Id).First() };
listContacts = contacts.Read(filter, new readContacts().IncludeAll().IncludeFields(fields));
Assert.IsTrue(listContacts.Count == 1);
filter.listId = new string[] { listResult.Items.Select(x => x.Id).Last() };
listContacts = contacts.Read(filter, new readContacts().IncludeAll().IncludeFields(fields));
Assert.IsTrue(listContacts.Count == 0);
listResult = lists.Delete(mailLists);
Assert.IsFalse(listResult.HasErrors, "Unable to delete the lists");
contactResult = contacts.Delete(new List <contactObject>()
{
contact
});
Assert.IsFalse(contactResult.HasErrors, "Unable to delete the contact");
}
