public void ToStringSimple01()
{
string s;
StdContact s0 = new StdContact();
s0.PersonGender = Gender.Unspecified;
s0.DateOfBirth = default(DateTime);
s0.Name = (PersonName)null;
s0.PersonalAddressPrimary = (AddressDetail)null;
s0.PersonalAddressSecondary = (AddressDetail)null;
s0.PersonalPhoneMobile = (PhoneNumber)null;
s0.PersonalEmailPrimary = (string)null;
s0.PersonalEmailSecondary = (string)null;
s0.PersonalHomepage = (string)null;
s0.PersonalInstantMessengerAddresses = (InstantMessengerAddresses)null;
s0.PersonalProfileIdentifiers = (ProfileIdentifiers)null;
s0.BusinessCompanyName = (string)null;
s0.BusinessDepartment = (string)null;
s0.BusinessAddressPrimary = (AddressDetail)null;
s0.BusinessAddressSecondary = (AddressDetail)null;
s0.BusinessPhoneMobile = (PhoneNumber)null;
s0.BusinessEmailPrimary = (string)null;
s0.BusinessEmailSecondary = (string)null;
s0.BusinessPosition = (string)null;
s0.BusinessHomepage = (string)null;
s0.BusinessInstantMessengerAddresses = (InstantMessengerAddresses)null;
s0.AdditionalTextData = (string)null;
s0.PictureName = (string)null;
s0.PictureData = (byte[])null;
((StdElement)s0).Id = default(Guid);
((StdElement)s0).InternalSyncData = (SyncData)null;
s = this.ToStringSimple(s0);
Assert.AreEqual <string>("", s);
}
public void PropertyPathWithNoNullToPropertyWithTransformation()
{
// register the property mapping of a source and a destination
// type with trasformations (in this case we do add a string to
// the name to generate a calendar title of "Birthday: Riddle, Tom")
var mapper = new Mapper();
mapper.Register <StdContact, StdCalendarItem>(
contact => contact.PersonalAddressPrimary.Phone,
(calendar, entity) => calendar.Title = entity == null ? "NULL detected" : "Call to " + entity);
// setup a source and a destination object
var source = new StdContact {
PersonalAddressPrimary = new AddressDetail {
Phone = "0123-456789"
}
};
var target = new StdCalendarItem();
// perform the mapping
mapper.Map(source, target);
// test it
Assert.AreEqual("Call to (123) 456789", target.Title);
}
/// <summary>
/// Converts a list of standard contacts to a list of standard elements
/// </summary>
/// <param name="list">
/// a list of standard contacts to cast
/// </param>
/// <returns>
/// a list of casted elements
/// </returns>
public static List <StdContact> ToStdContacts(this IEnumerable <StdElement> list)
{
var result = new List <StdContact>();
foreach (var element in list)
{
var e = element as StdContact;
if (e == null)
{
var m = element as MatchingEntry;
if (m != null)
{
e = new StdContact {
Id = element.Id, ExternalIdentifier = m.ProfileId
};
}
}
if (e != null)
{
result.Add(e);
}
}
return(result);
}
/// <summary>
/// Converts a <see cref="StdContact"/> to an Exchange API <see cref="Contact"/>
/// </summary>
/// <param name="contact">
/// The contact to be converted.
/// </param>
/// <param name="service">
/// The exchange service.
/// </param>
/// <returns>
/// the converted contact element
/// </returns>
public static Contact ToExchangeContact(this StdContact contact, ExchangeService service)
{
var exchangeContact = new Contact(service);
exchangeContact.UpdateFromStdContact(contact);
return(exchangeContact);
}
/// <summary>
/// sets the correct IM address from a google contacts Ims
/// </summary>
/// <param name="stdEntry">The std entry.</param>
/// <param name="instantMessengerAddress">The IM address.</param>
public static void SetInstantMessenger(this StdContact stdEntry, IMAddress instantMessengerAddress)
{
if (stdEntry.PersonalInstantMessengerAddresses == null)
{
stdEntry.PersonalInstantMessengerAddresses = new InstantMessengerAddresses();
}
if (instantMessengerAddress.Home)
{
switch (instantMessengerAddress.Protocol)
{
case "msn":
stdEntry.PersonalInstantMessengerAddresses.MsnMessenger = instantMessengerAddress.Address;
break;
}
}
if (instantMessengerAddress.Work)
{
switch (instantMessengerAddress.Protocol)
{
case "msn":
stdEntry.BusinessInstantMessengerAddresses.MsnMessenger = instantMessengerAddress.Address;
break;
}
}
}
/// <summary>
/// sets the correct phone number from a google contacts email
/// </summary>
/// <param name="stdEntry">The std entry.</param>
/// <param name="phoneNumber">The phone number to set into the std entry.</param>
public static void SetPhone(this StdContact stdEntry, global::Google.GData.Extensions.PhoneNumber phoneNumber)
{
var stdPhoneNumber = new PhoneNumber(phoneNumber.Value);
if (phoneNumber.Home)
{
stdEntry.PersonalAddressPrimary = stdEntry.PersonalAddressPrimary ?? new AddressDetail();
stdEntry.PersonalAddressPrimary.Phone = stdPhoneNumber;
}
if (phoneNumber.Work)
{
stdEntry.BusinessAddressPrimary = stdEntry.BusinessAddressPrimary ?? new AddressDetail();
stdEntry.BusinessAddressPrimary.Phone = stdPhoneNumber;
}
if (phoneNumber.Rel == GoogleSchemaPrefix2005 + "mobile")
{
if (stdEntry.PersonalPhoneMobile == null)
{
stdEntry.PersonalPhoneMobile = stdPhoneNumber;
}
else
{
stdEntry.BusinessPhoneMobile = stdPhoneNumber;
}
}
}
/// <summary>
/// doenloads the image for a contact
/// </summary>
/// <param name="stdEntry">The std entry.</param>
/// <param name="googleContact">The google contact.</param>
/// <param name="requester">The requester.</param>
public static void SetPicture(this StdContact stdEntry, Contact googleContact, ContactsRequest requester)
{
if (googleContact == null || googleContact.PhotoUri == null)
{
return;
}
try
{
using (var stream = requester.GetPhoto(googleContact))
{
if (stream != null)
{
var value = new StreamReader(stream).ReadToEnd();
stdEntry.PictureData = Encoding.ASCII.GetBytes(value);
}
}
}
catch (GDataNotModifiedException)
{
var helper = HttpHelper.DefaultInstance;
helper.ContentCredentials.LogOnDomain = "[GOOGLE]";
helper.ContentCredentials.LogOnPassword =
((GDataGAuthRequestFactory)requester.Service.RequestFactory).GAuthToken;
stdEntry.PictureData = helper.GetContentBinary(googleContact.PhotoUri.AbsoluteUri, string.Empty, string.Empty);
}
}
public string ToStringSimple([PexAssumeUnderTest] StdContact target)
{
// TODO: add assertions to method StdContactTest.ToStringSimple(StdContact)
string result = target.ToStringSimple();
return(result);
}
/// <summary>
/// Sets a postal address from the google contact into the std contact.
/// </summary>
/// <param name="stdEntry">The std entry to be updated.</param>
/// <param name="address">The address to set.</param>
public static void SetAddress(this StdContact stdEntry, StructuredPostalAddress address)
{
var stdAddress = new AddressDetail(address.FormattedAddress);
if (address.Usage == "home")
{
if (stdEntry.PersonalAddressPrimary == null)
{
stdEntry.PersonalAddressPrimary = stdAddress;
}
else
{
stdEntry.PersonalAddressSecondary = stdAddress;
}
}
if (address.Usage == "Work")
{
if (stdEntry.BusinessAddressPrimary == null)
{
stdEntry.BusinessAddressPrimary = stdAddress;
}
else
{
stdEntry.BusinessAddressSecondary = stdAddress;
}
}
}
/// <summary>
/// Overrides the method to read the full list of data.
/// </summary>
/// <param name="clientFolderName">
/// The exchange folder name to read from.
/// </param>
/// <param name="result">
/// The result list.
/// </param>
/// <returns>
/// The list of <see cref="StdContact"/> elements from the source.
/// </returns>
protected override List <StdElement> ReadFullList(string clientFolderName, List <StdElement> result)
{
if (result == null)
{
throw new ArgumentNullException("result");
}
var contactsFolder = this.GetContactsFolder(clientFolderName);
var offset = 0;
var itemsLeft = true;
while (itemsLeft)
{
var resultList =
contactsFolder.FindItems(
new ItemView(100, offset, OffsetBasePoint.Beginning)
{
PropertySet = BasePropertySet.IdOnly,
Traversal = ItemTraversal.Shallow
});
itemsLeft = resultList.Items.Count == 100;
foreach (var element in resultList)
{
var currentItem = element as Contact;
if (currentItem == null)
{
continue;
}
StdContact contact = null;
ExceptionHandler.Suppress(
() =>
{
var exchangeContact = Contact.Bind(contactsFolder.Service, currentItem.Id);
contact = exchangeContact.ToStdContact();
},
(Exception ex) => true);
if (contact == null || string.IsNullOrEmpty(contact.Name.ToString()))
{
continue;
}
result.Add(contact);
this.LogProcessingEvent(contact, Properties.Resources.ElementLoaded);
}
CleanUpEntities(result);
this.LogProcessingEvent(Properties.Resources.ElementsLoaded, result.Count);
offset += 100;
}
return(result);
}
/// <summary>
/// Overrides the method to read the full list of data. This will read ALL data from the Google Contacts
/// account, even if it has already been downloaded in the past.
/// </summary>
/// <param name="clientFolderName">The parameter clientFolderName is ignored by this connector implementation.</param>
/// <param name="result">A list of StdElements that will get the new imported entries.</param>
/// <returns>The list with the added contacts</returns>
protected override List <StdElement> ReadFullList(string clientFolderName, List <StdElement> result)
{
try
{
this.LogProcessingEvent("downloading contacts ...");
this.EnsureInitialization();
var contactsCollection = this.requester.GetContacts();
foreach (var googleContact in contactsCollection.Entries)
{
try
{
// get the SemSync Contact ID from the google entity (if there is one)
var semSyncIdString =
(from x in googleContact.ExtendedProperties where x.Name == "SemSyncId" select x.Value)
.FirstOrDefault();
// if we didn't set one, create a new Guid, otherwise reconstruct the Guid from the string stored in th Google contact
var semSyncId = string.IsNullOrEmpty(semSyncIdString)
? Guid.NewGuid()
: new Guid(semSyncIdString);
// create a new contact entity
var stdEntry = new StdContact
{
Id = semSyncId,
Name = new PersonName(googleContact.Title),
ExternalIdentifier = new ProfileIdentifierDictionary(ProfileIdentifierType.Google, googleContact.Id)
};
this.LogProcessingEvent("mapping contact {0} ...", stdEntry.Name.ToString());
googleContact.SetSyncIdentifier(semSyncId);
// the ForEach is an extension method that calls the lambda for each element of an IEnumerable
googleContact.PostalAddresses.ForEach(stdEntry.SetAddress);
googleContact.Organizations.ForEach(stdEntry.SetBusiness);
googleContact.Phonenumbers.ForEach(stdEntry.SetPhone);
googleContact.Emails.ForEach(stdEntry.SetEmail);
googleContact.IMs.ForEach(stdEntry.SetInstantMessenger);
// downloads the image
this.LogProcessingEvent("downloading picture {0} ...", stdEntry.Name.ToString());
stdEntry.SetPicture(googleContact, this.requester);
result.Add(stdEntry);
}
catch (GDataRequestException ex)
{
this.LogProcessingEvent("Error while executing client: {0}", ex.Message);
}
}
}
catch (GDataRequestException ex)
{
this.LogProcessingEvent("Error while executing client: {0}", ex.Message);
}
return(result);
}
/// <summary>
/// Extract contact information from an Active Directory entry
/// </summary>
/// <param name="resultProperties"> </param>
/// <returns> a standard contact entity </returns>
private static StdContact ConvertToContact(PropertyCollection resultProperties)
{
var result = new StdContact
{
Id = Guid.NewGuid(),
InternalSyncData =
new SyncData
{
DateOfCreation = resultProperties.GetPropDate("whencreated"),
DateOfLastChange = resultProperties.GetPropDate("whenchanged"),
},
BusinessAddressPrimary =
new AddressDetail
{
CountryName = resultProperties.GetPropString("co"),
StateName = resultProperties.GetPropString("st"),
PostalCode = resultProperties.GetPropString("postalcode"),
CityName = resultProperties.GetPropString("l"),
StreetName = resultProperties.GetPropString("streetaddress"),
Phone = new PhoneNumber(resultProperties.GetPropString("telephonenumber")),
Room = resultProperties.GetPropString("physicaldeliveryofficename", "roomnumber"),
},
BusinessPhoneMobile = new PhoneNumber(resultProperties.GetPropString("mobile")),
BusinessPosition = resultProperties.GetPropString("title"),
BusinessCompanyName = resultProperties.GetPropString("company"),
BusinessDepartment = resultProperties.GetPropString("department"),
BusinessEmailPrimary = resultProperties.GetPropString("mail"),
PersonalAddressPrimary =
new AddressDetail
{
Phone = new PhoneNumber(resultProperties.GetPropString("homephone")),
},
Name =
new PersonName
{
FirstName = resultProperties.GetPropString("givenname"),
LastName = resultProperties.GetPropString("sn"),
},
PersonGender = SyncTools.GenderByText(resultProperties.GetPropString("personaltitle")),
AdditionalTextData = resultProperties.GetPropString("info"),
ImageEntries = new List <ImageEntry>
{
new ImageEntry
{
ImageData = resultProperties.GetPropBytes("thumbnailPhoto"),
ImageName = "ActiveDirectory",
}
}
};
result.ExternalIdentifier.SetProfileId(ProfileIdentifierType.ActiveDirectoryId, resultProperties.GetPropString("CN"));
result.NormalizeContent();
return(result);
}
/// <summary>
/// Convert MeinVZ contact url to <see cref="StdContact"/>
/// </summary>
/// <param name="contactUrl">
/// The contact url.
/// </param>
/// <returns>
/// the downloaded information inserted into a <see cref="StdContact"/>
/// </returns>
private StdContact DownloadContact(string contactUrl)
{
var result = new StdContact();
var content = this.httpRequester.GetContent(contactUrl, contactUrl, string.Empty);
var imageUrl = Regex.Match(content, this.ContactImageSelector, RegexOptions.Singleline);
if (imageUrl != null)
{
var url = imageUrl.Groups[1].ToString();
if (!string.IsNullOrEmpty(url))
{
result.PictureName = url.Substring(url.LastIndexOf('/') + 1);
result.PictureData = this.httpRequester.GetContentBinary(url, url);
}
}
foreach (Match match in Regex.Matches(content, ContactContentSelector, RegexOptions.Singleline))
{
var key = match.Groups[1].ToString();
var value = match.Groups[2].ToString();
try
{
if (key != "Geburtstag:" && value.Contains(">"))
{
value = value.Substring(value.IndexOf('>') + 1);
}
if (value.Contains("<"))
{
value = value.Substring(0, value.IndexOf('<'));
}
MapKeyValuePair(result, value, key);
}
catch (Exception ex)
{
throw new TechnicalException(
"Problem mapping key value pair from web page.",
ex,
new KeyValuePair <string, object>("key", key),
new KeyValuePair <string, object>("value", value));
}
}
result.ExternalIdentifier.SetProfileId(
ProfileIdentifierType.MeinVZ,
contactUrl.Substring(contactUrl.LastIndexOf("/", StringComparison.Ordinal) + 1));
this.ThinkTime(1000);
this.LogProcessingEvent(result, "downloaded");
return(result);
}
/// <summary>
/// Sets the organization info including the business position.
/// </summary>
/// <param name="stdEntry">The std entry.</param>
/// <param name="organization">The organization information from the google contact.</param>
public static void SetBusiness(this StdContact stdEntry, Organization organization)
{
if (!organization.Primary &&
!string.IsNullOrEmpty(stdEntry.BusinessCompanyName))
{
return;
}
stdEntry.BusinessPosition = organization.Title;
stdEntry.BusinessCompanyName = organization.Name;
}
public void TestCategorySelectorWrite()
{
var contact = new StdContact();
Tools.SetPropertyValue(contact, "Categories", "cat1|category 1|!important!");
Assert.AreEqual("cat1|category 1|!important!", Tools.GetPropertyValueString(contact, "Categories"));
Assert.AreEqual("cat1", contact.Categories[0]);
Assert.AreEqual("category 1", contact.Categories[1]);
Assert.AreEqual("!important!", contact.Categories[2]);
}
/// <summary>
/// Creates a <see cref="StdContact"/> entity with only the Xing profile ID specified for matching simulation.
/// </summary>
/// <param name="profileTypeId"></param>
/// <param name="profileId">
/// The profile id.
/// </param>
/// <param name="id"> The <see cref="StdElement.Id"/>. </param>
/// <returns> The entity created with a Xing profile id. </returns>
private static StdContact CreateIdOnlyContact(ProfileIdentifierType profileTypeId, string profileId, string id)
{
var result = new StdContact
{
Name = new PersonName(profileId),
Id = new Guid(id),
ExternalIdentifier = new ProfileIdentifierDictionary(profileTypeId, profileId),
};
return(result);
}
public void TestCategorySelectorRead()
{
var contact = new StdContact {
Categories = new List <string> {
"cat1", "category 1", "!important!"
}
};
Assert.AreEqual("cat1", Tools.GetPropertyValueString(contact, "Categories[0]"));
Assert.AreEqual("category 1", Tools.GetPropertyValueString(contact, "Categories[1]"));
Assert.AreEqual("!important!", Tools.GetPropertyValueString(contact, "Categories[2]"));
Assert.AreEqual("cat1|category 1|!important!", Tools.GetPropertyValueString(contact, "Categories"));
}
/// <summary>
/// sets the correct email address from a google contacts email
/// </summary>
/// <param name="stdEntry">The std entry.</param>
/// <param name="email">The email address.</param>
public static void SetEmail(this StdContact stdEntry, EMail email)
{
if (email.Home)
{
stdEntry.PersonalEmailPrimary = email.Address;
}
if (email.Work)
{
stdEntry.BusinessEmailPrimary = email.Address;
}
if (!email.Home && !email.Work && string.IsNullOrEmpty(stdEntry.PersonalEmailPrimary))
{
stdEntry.PersonalEmailPrimary = email.Address;
}
}
/// <summary>
/// Performs a match by comparing email addresses
/// </summary>
/// <param name="element1">
/// The first element to test.
/// </param>
/// <param name="element2">
/// The second element to test.
/// </param>
/// <returns>
/// true in case of a match in one or more email addresses
/// </returns>
private static bool IsEmailMatch(StdContact element1, StdContact element2)
{
if (IsValidEmailAddress(element1.PersonalEmailPrimary) &&
element1.PersonalEmailPrimary.IsOneOf(
element2.PersonalEmailPrimary,
element2.PersonalEmailSecondary,
element2.BusinessEmailPrimary,
element2.PersonalEmailSecondary))
{
return(true);
}
if (IsValidEmailAddress(element1.PersonalEmailSecondary) &&
element1.PersonalEmailPrimary.IsOneOf(
element2.PersonalEmailPrimary,
element2.PersonalEmailSecondary,
element2.BusinessEmailPrimary,
element2.PersonalEmailSecondary))
{
return(true);
}
if (IsValidEmailAddress(element1.BusinessEmailPrimary) &&
element1.PersonalEmailPrimary.IsOneOf(
element2.PersonalEmailPrimary,
element2.PersonalEmailSecondary,
element2.BusinessEmailPrimary,
element2.PersonalEmailSecondary))
{
return(true);
}
if (IsValidEmailAddress(element1.BusinessEmailSecondary) &&
element1.PersonalEmailPrimary.IsOneOf(
element2.PersonalEmailPrimary,
element2.PersonalEmailSecondary,
element2.BusinessEmailPrimary,
element2.PersonalEmailSecondary))
{
return(true);
}
return(false);
}
/// <summary>
/// Reads all data from the configured table and maps it to the <see cref="StdContact"/> entity.
/// This method does use an unconditional SELECT * FROM ..., so it might affect performance
/// in case of large result sets.
/// </summary>
/// <param name="clientFolderName">
/// the configuration file for the data source
/// </param>
/// <param name="result">
/// The list of elements that should get the elements. The elements
/// will be added to the list instead of replacing it.
/// </param>
/// <returns>
/// The list with the newly added elements
/// </returns>
protected override List <StdElement> ReadFullList(string clientFolderName, List <StdElement> result)
{
var description = GetDescription(clientFolderName);
var mappings = description.ColumnDefinitions;
using (var con = new OleDbConnection(GetConnectionString(description)))
{
con.Open();
using (var cmd = con.CreateCommand())
{
cmd.CommandText = GenerateSelectStatement(description);
var reader = cmd.ExecuteReader();
while (reader.Read())
{
var newContact = new StdContact();
foreach (var mappingItem in mappings)
{
try
{
var value = reader[mappingItem.Title].ToString();
if (mappingItem.TransformationFromDatabase != null)
{
value =
mappingItem.TransformationFromDatabase.Compile()(mappingItem, value).ToString();
}
Tools.SetPropertyValue(newContact, mappingItem.Selector, value);
}
catch (Exception ex)
{
this.LogException(ex);
}
}
result.Add(newContact);
}
}
}
return(result);
}
/// <summary>
/// Creates or updates photo information for a google contact with the information found in the std-contact.
/// </summary>
/// <param name="googleContact">The google contact.</param>
/// <param name="contact">The contact containing the image information.</param>
/// <param name="credentials">The credentials providing object.</param>
public static void UpdatePhoto(this Contact googleContact, StdContact contact, ContactClient credentials)
{
if (contact.PictureData == null || contact.PictureData.Length <= 0 || string.IsNullOrEmpty(googleContact.Id))
{
return;
}
var rs = new RequestSettings("Sem.Sync.Connector.Google", credentials.LogOnUserId, credentials.LogOnPassword)
{
AutoPaging = true
};
var cr = new ContactsRequest(rs);
using (var photoStream = new MemoryStream(contact.PictureData))
{
for (var i = 0; i < 3; i++)
{
try
{
cr.SetPhoto(googleContact, photoStream);
break;
}
catch (GDataRequestException ex)
{
credentials.LogError(ex);
if (string.IsNullOrEmpty(ex.ResponseString))
{
break;
}
}
catch (CaptchaRequiredException)
{
UnlockCaptch();
}
catch (Exception ex)
{
credentials.LogError(ex);
break;
}
}
}
}
/// <summary>
/// Adds profile ids to a contacts "contact list" with filtering its own
/// profile id and preventing doubletts.
/// </summary>
/// <param name="contact"> The contact (source of the link). </param>
/// <param name="profileIds"> The profile ids to be added as link targets. </param>
/// <param name="baseline"> The baseline. </param>
/// <param name="added"> The number of targets added so far. </param>
/// <returns> The number of links added </returns>
private int AddContactIdsToStdContact(StdContact contact, List <string> profileIds, IEnumerable <MatchingEntry> baseline, int added)
{
var profileIdentifierType = this.WebSideParameters.ProfileIdentifierType;
contact.Contacts = contact.Contacts ?? new List <ContactReference>(profileIds.Count);
foreach (var extract in profileIds)
{
var profileId = string.Format(this.WebSideParameters.ProfileIdFormatter, extract);
var stdId =
(from x in baseline
where x.ProfileId.GetProfileId(profileIdentifierType) == profileId
select x.Id).FirstOrDefault();
// we ignore contacts we donn't know
if (stdId == default(Guid))
{
continue;
}
// lookup an existing entry in this contacts contact-list
var contactInList = (from x in contact.Contacts where x.Target == stdId select x).FirstOrDefault();
if (contactInList == null)
{
// add a new one if no existing entry has been found
contactInList = new ContactReference {
Target = stdId
};
contact.Contacts.Add(contactInList);
added++;
}
// update the flag that this entry is a private contact
var connectorDescriptionAttribute = this.ConnectorDescription;
contactInList.IsPrivateContact = connectorDescriptionAttribute.ContentIsPrivate;
contactInList.IsBusinessContact = connectorDescriptionAttribute.ContentIsBusiness;
}
return(added);
}
private static bool UpdateUser(StdContact newItem, DirectoryEntry user)
{
var oldItem = ConvertToContact(user.Properties);
var dirty = false;
MappingHelper.MapIfDiffers(ref dirty, oldItem, newItem, x => x.Name.FirstName, x => user.SetPropertyValue("givenname", x));
MappingHelper.MapIfDiffers(ref dirty, oldItem, newItem, x => x.Name.LastName, x => user.SetPropertyValue("sn", x));
MappingHelper.MapIfDiffers(ref dirty, oldItem, newItem, x => x.BusinessAddressPrimary.CountryName, x => user.SetPropertyValue("co", x));
MappingHelper.MapIfDiffers(ref dirty, oldItem, newItem, x => x.BusinessAddressPrimary.StateName, x => user.SetPropertyValue("st", x));
MappingHelper.MapIfDiffers(ref dirty, oldItem, newItem, x => x.BusinessAddressPrimary.PostalCode, x => user.SetPropertyValue("postalcode", x));
MappingHelper.MapIfDiffers(ref dirty, oldItem, newItem, x => x.BusinessAddressPrimary.StreetName, x => user.SetPropertyValue("streetaddress", x));
MappingHelper.MapIfDiffers(ref dirty, oldItem, newItem, x => x.BusinessAddressPrimary.Phone.ToString(), x => user.SetPropertyValue("telephonenumber", x));
MappingHelper.MapIfDiffers(ref dirty, oldItem, newItem, x => x.BusinessAddressPrimary.Room, x => user.SetPropertyValue("physicaldeliveryofficename", x));
MappingHelper.MapIfDiffers(ref dirty, oldItem, newItem, x => x.BusinessPhoneMobile.ToString(), x => user.SetPropertyValue("mobile", x));
MappingHelper.MapIfDiffers(ref dirty, oldItem, newItem, x => x.BusinessPosition, x => user.SetPropertyValue("title", x));
MappingHelper.MapIfDiffers(ref dirty, oldItem, newItem, x => x.BusinessCompanyName, x => user.SetPropertyValue("company", x));
MappingHelper.MapIfDiffers(ref dirty, oldItem, newItem, x => x.BusinessDepartment, x => user.SetPropertyValue("department", x));
MappingHelper.MapIfDiffers(ref dirty, oldItem, newItem, x => x.BusinessEmailPrimary, x => user.SetPropertyValue("mail", x));
MappingHelper.MapIfDiffers(ref dirty, oldItem, newItem, x => x.PersonalAddressPrimary.Phone.ToString(), x => user.SetPropertyValue("homephone", x));
MappingHelper.MapIfDiffers(ref dirty, oldItem, newItem, x => x.AdditionalTextData, x => user.SetPropertyValue("info", x));
if (newItem.ImageEntries != null &&
newItem.ImageEntries.Count > 0 &&
newItem.ImageEntries[0] != null &&
(oldItem.ImageEntries == null ||
oldItem.ImageEntries.Count == 0 ||
oldItem.ImageEntries[0] == null ||
newItem.ImageEntries[0].ImageData.Length > oldItem.ImageEntries[0].ImageData.Length))
{
user.Properties["thumbnailPhoto"].Value = newItem.ImageEntries[0].ImageData;
dirty = true;
}
return(dirty);
}
public void FunctionCallToPropertyWithTransformation()
{
// register the property mapping of a source and a destination
// type with trasformations (in this case we do add a string to
// the name to generate a calendar title of "Birthday: Riddle, Tom")
var mapper = new Mapper();
mapper.Register <StdContact, StdCalendarItem>(contact => contact.Id, (calendar, entity) => calendar.Id = (Guid)entity);
mapper.Register <StdContact, StdCalendarItem>(contact => contact.GetFullName(), (calendar, entity) => calendar.Title = "Birthday: " + entity);
// setup a source and a destination object
var source = new StdContact {
Name = new PersonName("Tom Riddle")
};
var target = new StdCalendarItem();
// perform the mapping
mapper.Map(source, target);
// test it
Assert.AreEqual(source.Id, target.Id);
Assert.AreEqual("Birthday: " + source.GetFullName(), target.Title);
}
/// <summary>
/// writes a contact to outlook
/// </summary>
/// <param name="contactsEnum">
/// The contacts enum.
/// </param>
/// <param name="element">
/// The element.
/// </param>
/// <param name="skipIfExisting">
/// The skip if existing.
/// </param>
/// <param name="contactsList">
/// The contacts list.
/// </param>
/// <returns>
/// a value indicating if the contact has been saved
/// </returns>
/// <exception cref="ArgumentNullException">
/// in case of contactsEnum or element being null
/// </exception>
internal static bool WriteContactToOutlook(
Items contactsEnum, StdContact element, bool skipIfExisting, IEnumerable <ContactsItemContainer> contactsList)
{
if (contactsEnum == null)
{
throw new ArgumentNullException("contactsEnum");
}
if (element == null)
{
throw new ArgumentNullException("element");
}
var outlookContact =
(from x in contactsList where x.Id == element.Id.ToString() select x.Item).FirstOrDefault();
if (skipIfExisting && outlookContact != null)
{
return(false);
}
if (outlookContact == null)
{
outlookContact = (ContactItem)contactsEnum.Add(OlItemType.olContactItem);
}
// convert StdContact to Outlook contact
if (ConvertToNativeContact(element, outlookContact))
{
outlookContact.Save();
GCRelevantCall();
return(true);
}
GCRelevantCall();
return(false);
}
/// <summary>
/// Compares two contact instances and reports the difference.
/// </summary>
/// <param name="baselineContact">
/// The contact from the base line (how it has been read last time).
/// </param>
/// <param name="currentContact">
/// The contact currently read from the source.
/// </param>
private void CompareEntities(StdContact baselineContact, StdContact currentContact)
{
var changes =
SyncTools.DetectConflicts(
SyncTools.BuildConflictTestContainerList(
new List <StdElement>(new[] { currentContact }),
new List <StdElement>(new[] { baselineContact }),
null,
typeof(StdContact)),
true);
var changeSet = new ChangeInfo();
foreach (var change in changes)
{
changeSet.ChangedProperties.Add(
change.PathToProperty + " " + change.PropertyConflict + ": " + change.SourceElement);
}
if (changeSet.ChangedProperties.Count <= 0)
{
return;
}
changeSet.DisplayName = string.Format(
CultureInfo.InvariantCulture,
"{0} has {1} properties changed.",
baselineContact.Name,
changeSet.ChangedProperties.Count);
this.DetectedChanges.Add(changeSet);
while (this.DetectedChanges.Count > this.MaxEntries)
{
this.DetectedChanges.RemoveAt(0);
}
}
private static bool ConvertToNativeContact(StdContact stdNewContact, ContactItem outlookContact)
{
var dirty = false;
var stdOldContact = ConvertToStandardContact(outlookContact, null);
var gender = stdNewContact.PersonGender == Gender.Unspecified
? OlGender.olUnspecified
: ((stdNewContact.PersonGender == Gender.Male) ? OlGender.olMale : OlGender.olFemale);
SyncTools.ClearNulls(stdNewContact, typeof(StdContact));
SyncTools.ClearNulls(stdOldContact, typeof(StdContact));
MappingHelper.MapIfDiffers(
ref dirty, stdNewContact, stdOldContact, x => x.DateOfBirth, x => outlookContact.Birthday = x);
MappingHelper.MapIfDiffers(
ref dirty, stdNewContact, stdOldContact, x => x.PersonGender, x => outlookContact.Gender = gender);
MappingHelper.MapIfDiffers(
ref dirty, stdNewContact, stdOldContact, x => x.Name.FirstName, x => outlookContact.FirstName = x);
MappingHelper.MapIfDiffers(
ref dirty, stdNewContact, stdOldContact, x => x.Name.MiddleName, x => outlookContact.MiddleName = x);
MappingHelper.MapIfDiffers(
ref dirty, stdNewContact, stdOldContact, x => x.Name.LastName, x => outlookContact.LastName = x);
MappingHelper.MapIfDiffers(
ref dirty, stdNewContact, stdOldContact, x => x.Name.AcademicTitle, x => outlookContact.Title = x);
MappingHelper.MapIfDiffers(
ref dirty,
stdNewContact,
stdOldContact,
x => x.BusinessEmailPrimary,
x => outlookContact.Email2Address = x);
MappingHelper.MapIfDiffers(
ref dirty,
stdNewContact,
stdOldContact,
x => x.PersonalEmailPrimary,
x => outlookContact.Email1Address = x);
MappingHelper.MapIfDiffers(
ref dirty,
stdNewContact,
stdOldContact,
x => x.BusinessHomepage,
x => outlookContact.BusinessHomePage = x);
MappingHelper.MapIfDiffers(
ref dirty,
stdNewContact,
stdOldContact,
x => x.PersonalHomepage,
x => outlookContact.PersonalHomePage = x);
MappingHelper.MapIfDiffers(
ref dirty, stdNewContact, stdOldContact, x => x.BusinessCompanyName, x => outlookContact.CompanyName = x);
MappingHelper.MapIfDiffers(
ref dirty, stdNewContact, stdOldContact, x => x.BusinessPosition, x => outlookContact.JobTitle = x);
MappingHelper.MapIfDiffers(
ref dirty,
stdNewContact,
stdOldContact,
x => x.BusinessAddressPrimary.CityName,
x => outlookContact.BusinessAddressCity = x);
MappingHelper.MapIfDiffers(
ref dirty,
stdNewContact,
stdOldContact,
x => x.BusinessAddressPrimary.CountryName,
x => outlookContact.BusinessAddressCountry = x);
MappingHelper.MapIfDiffers(
ref dirty,
stdNewContact,
stdOldContact,
x => x.BusinessAddressPrimary.PostalCode,
x => outlookContact.BusinessAddressPostalCode = x);
MappingHelper.MapIfDiffers(
ref dirty,
stdNewContact,
stdOldContact,
x => x.BusinessAddressPrimary.StateName,
x => outlookContact.BusinessAddressState = x);
MappingHelper.MapIfDiffers(
ref dirty,
stdNewContact,
stdOldContact,
x => x.BusinessAddressPrimary.StreetName,
x => outlookContact.BusinessAddressStreet = x);
MappingHelper.MapIfDiffers(
ref dirty,
stdNewContact,
stdOldContact,
x => x.BusinessAddressPrimary.Phone.ToString(),
x => outlookContact.BusinessTelephoneNumber = x);
MappingHelper.MapIfDiffers(
ref dirty,
stdNewContact,
stdOldContact,
x => x.PersonalAddressPrimary.CityName,
x => outlookContact.HomeAddressCity = x);
MappingHelper.MapIfDiffers(
ref dirty,
stdNewContact,
stdOldContact,
x => x.PersonalAddressPrimary.CountryName,
x => outlookContact.HomeAddressCountry = x);
MappingHelper.MapIfDiffers(
ref dirty,
stdNewContact,
stdOldContact,
x => x.PersonalAddressPrimary.PostalCode,
x => outlookContact.HomeAddressPostalCode = x);
MappingHelper.MapIfDiffers(
ref dirty,
stdNewContact,
stdOldContact,
x => x.PersonalAddressPrimary.StateName,
x => outlookContact.HomeAddressState = x);
MappingHelper.MapIfDiffers(
ref dirty,
stdNewContact,
stdOldContact,
x => x.PersonalAddressPrimary.StreetName,
x => outlookContact.HomeAddressStreet = x);
MappingHelper.MapIfDiffers(
ref dirty,
stdNewContact,
stdOldContact,
x => x.PersonalAddressPrimary.Phone.ToString(),
x => outlookContact.HomeTelephoneNumber = x);
MappingHelper.MapIfDiffers(
ref dirty,
stdNewContact,
stdOldContact,
x => x.PersonalPhoneMobile.ToString(),
x => outlookContact.MobileTelephoneNumber = x);
MappingHelper.MapIfDiffers(
ref dirty,
stdNewContact,
stdOldContact,
x => x.BusinessPhoneMobile.ToString(),
x => outlookContact.Business2TelephoneNumber = x);
MappingHelper.MapIfDiffers(
ref dirty,
stdNewContact,
stdOldContact,
x => x.PersonalInstantMessengerAddresses.MsnMessenger,
x => outlookContact.IMAddress = x);
MappingHelper.MapIfDiffers(
ref dirty,
stdNewContact,
stdOldContact,
x => x.AdditionalTextData.Replace("\r\n", "\n"),
x => outlookContact.Body = x);
if (stdOldContact.Id != stdNewContact.Id)
{
outlookContact.UserProperties.Add(ContactIdOutlookPropertyName, OlUserPropertyType.olText, true, 1).
Value = stdNewContact.Id.ToString();
dirty = true;
}
// import pictures if we have more data inside the new contact
if (stdNewContact.PictureData != null && stdNewContact.PictureData.Length > stdOldContact.PictureData.Length)
{
var fullName = Path.GetTempFileName() + ".jpg";
File.WriteAllBytes(fullName, stdNewContact.PictureData);
outlookContact.AddPicture(fullName);
File.Delete(fullName);
dirty = true;
}
if (stdNewContact.Categories != null &&
(stdOldContact.Categories == null || stdNewContact.Categories.Count != stdOldContact.Categories.Count))
{
outlookContact.Categories = string.Join(
";", stdNewContact.Categories.MergeList(stdOldContact.Categories));
dirty = true;
}
return(dirty);
}
/// <summary>
/// Converts an outlook contact to a standard contact.
/// </summary>
/// <param name="outlookContact">
/// The outlook contact to be converted.
/// </param>
/// <param name="contactList">
/// The contact List to lookup duplicates.
/// </param>
/// <returns>
/// a new standard contact
/// </returns>
/// <exception cref="ArgumentNullException">
/// if the outlook contact is null
/// </exception>
internal static StdContact ConvertToStandardContact(
ContactItem outlookContact, IEnumerable <StdContact> contactList)
{
if (outlookContact == null)
{
throw new ArgumentNullException("outlookContact");
}
// generate the new id this contact will get in case there is no contact id in outlook
var newId = GetStandardContactId(outlookContact, contactList);
// read the picture data and name of this contact
string pictureName;
var pictureData = SaveOutlookContactPicture(outlookContact, out pictureName);
StdContact returnValue;
try
{
// create a new contact and assign the corresponding values from the outlook contact
returnValue = new StdContact
{
Id = newId,
InternalSyncData =
new SyncData
{
DateOfLastChange = outlookContact.LastModificationTime,
DateOfCreation = outlookContact.CreationTime
},
PersonGender =
(outlookContact.Gender == OlGender.olMale)
? Gender.Male
: (outlookContact.Gender == OlGender.olFemale)
? Gender.Female
: SyncTools.GenderByText(outlookContact.Title),
DateOfBirth = outlookContact.Birthday,
Name =
new PersonName
{
FirstName = outlookContact.FirstName,
LastName = outlookContact.LastName,
MiddleName = outlookContact.MiddleName,
AcademicTitle =
outlookContact.Title.IsOneOf("Herr", "Mr.", "Frau", "Mrs.")
? null
: outlookContact.Title,
},
PersonalAddressPrimary =
new AddressDetail
{
Phone =
(!string.IsNullOrEmpty(outlookContact.HomeTelephoneNumber))
? new PhoneNumber(outlookContact.HomeTelephoneNumber)
: null,
CountryName = outlookContact.HomeAddressCountry,
PostalCode = outlookContact.HomeAddressPostalCode,
CityName = outlookContact.HomeAddressCity,
StateName = outlookContact.HomeAddressState,
StreetName = outlookContact.HomeAddressStreet,
},
PersonalHomepage = outlookContact.PersonalHomePage,
PersonalEmailPrimary = outlookContact.Email1Address,
PersonalInstantMessengerAddresses =
string.IsNullOrEmpty(outlookContact.IMAddress)
? null
: new InstantMessengerAddresses(outlookContact.IMAddress),
PersonalPhoneMobile =
(!string.IsNullOrEmpty(outlookContact.MobileTelephoneNumber))
? new PhoneNumber(outlookContact.MobileTelephoneNumber)
: null,
BusinessCompanyName = outlookContact.CompanyName,
BusinessPosition = outlookContact.JobTitle,
BusinessAddressPrimary =
new AddressDetail
{
Phone =
(!string.IsNullOrEmpty(outlookContact.BusinessTelephoneNumber))
? new PhoneNumber(outlookContact.BusinessTelephoneNumber)
: null,
CountryName = outlookContact.BusinessAddressCountry,
PostalCode = outlookContact.BusinessAddressPostalCode,
CityName = outlookContact.BusinessAddressCity,
StateName = outlookContact.BusinessAddressState,
StreetName = outlookContact.BusinessAddressStreet,
},
BusinessHomepage = outlookContact.BusinessHomePage,
BusinessEmailPrimary = outlookContact.Email2Address,
BusinessPhoneMobile =
(!string.IsNullOrEmpty(outlookContact.Business2TelephoneNumber))
? new PhoneNumber(outlookContact.Business2TelephoneNumber)
: null,
AdditionalTextData = outlookContact.Body,
PictureName = pictureName,
PictureData = pictureData
};
}
catch (COMException ex)
{
if (ex.ErrorCode == -2147467260)
{
return(null);
}
throw;
}
if (!string.IsNullOrEmpty(outlookContact.Categories))
{
returnValue.Categories = MergeStrings(returnValue.Categories, outlookContact.Categories);
}
if (string.IsNullOrEmpty(returnValue.PersonalAddressPrimary.ToString()))
{
returnValue.PersonalAddressPrimary = null;
}
if (string.IsNullOrEmpty(returnValue.BusinessAddressPrimary.ToString()))
{
returnValue.PersonalAddressPrimary = null;
}
// return the newly generated standard contact
return(returnValue);
}
//private NotesDatabase _serverDatabase = null;
//private NotesView _peopleView = null;
//private string _lotusCientPassword = null;
//private string _lotusnotesserverName = null;
//private bool _IsfetchServerData = false;
#region Methods
/// <summary>
/// Overrides virtual read method for full list of elements
/// </summary>
/// <param name="clientFolderName">
/// the information from where inside the source the elements should be read -
/// This does not need to be a real "path", but need to be something that can be expressed as a string
/// </param>
/// <param name="result">
/// The list of elements that should get the elements. The elements should be added to
/// the list instead of replacing it.
/// </param>
/// <returns>
/// The list with the newly added elements
/// </returns>
protected override List <StdElement> ReadFullList(string clientFolderName, List <StdElement> result)
{
if (result == null)
{
throw new ArgumentNullException("result");
}
string currentElementName = string.Empty;
try
{
this.LogProcessingEvent(Resources.uiLogginIn);
//Lotus Notes Object Creation
_lotesNotesSession = new Domino.NotesSessionClass();
//Initializing Lotus Notes Session
_lotesNotesSession.Initialize(this.LogOnPassword); //Passwort
_localDatabase = _lotesNotesSession.GetDatabase("", "names.nsf", false); //Database for Contacts default names.nsf
this.LogProcessingEvent(Resources.uiPreparingList);
string viewname = "$People";
_contactsView = _localDatabase.GetView(viewname);
// TODO: implement reading from the Lotus Notes server and map the entities to StdContact instances
if (_contactsView == null)
{
this.LogProcessingEvent(Resources.uiNoViewFound, viewname);
}
else
{
NotesViewEntryCollection notesViewCollection = _contactsView.AllEntries;
//ArrayList notesUIDSList = new ArrayList();
for (int rowCount = 1; rowCount <= notesViewCollection.Count; rowCount++)
{
//Get the nth entry of the selected view according to the iteration.
NotesViewEntry viewEntry = notesViewCollection.GetNthEntry(rowCount);
//Get the first document of particular entry.
NotesDocument document = viewEntry.Document;
object documentItems = document.Items;
Array itemArray = (System.Array)documentItems;
StdContact elem = new StdContact();
PersonName name = new PersonName();
elem.Name = name;
AddressDetail businessAddress = new AddressDetail();
elem.BusinessAddressPrimary = businessAddress;
AddressDetail address = new AddressDetail();
elem.PersonalAddressPrimary = address;
elem.ExternalIdentifier.SetProfileId(ProfileIdentifierType.LotusNotesId, document.NoteID);
for (int itemCount = 0; itemCount < itemArray.Length; itemCount++)
{
NotesItem notesItem = (Domino.NotesItem)itemArray.GetValue(itemCount);
string itemname = notesItem.Name;
string text = notesItem.Text;
switch (notesItem.Name)
{
//Name
case "FirstName":
name.FirstName = notesItem.Text;
break;
case "LastName":
name.LastName = notesItem.Text;
break;
case "Titel":
{
if (notesItem.Text != "0")
{
name.AcademicTitle = notesItem.Text;
}
}
break;
//Geburtstag
case "Birthday":
DateTime dt;
if (DateTime.TryParse(notesItem.Text, out dt))
{
elem.DateOfBirth = dt;
}
break;
case "Comment":
elem.AdditionalTextData = notesItem.Text;
break;
//Business adress
case "InternetAddress":
elem.BusinessEmailPrimary = notesItem.Text;
break;
case "OfficePhoneNumber":
businessAddress.Phone = new PhoneNumber();
businessAddress.Phone.DenormalizedPhoneNumber = notesItem.Text;
break;
case "OfficeStreetAddress":
businessAddress.StreetName = notesItem.Text;
break;
case "OfficeState":
businessAddress.StateName = notesItem.Text;
break;
case "OfficeCity":
businessAddress.CityName = notesItem.Text;
break;
case "OfficeZIP":
businessAddress.PostalCode = notesItem.Text;
break;
case "OfficeCountry":
businessAddress.CountryName = notesItem.Text;
break;
//Business
case "Department":
elem.BusinessDepartment = notesItem.Text;
break;
case "CompanyName":
elem.BusinessCompanyName = notesItem.Text;
break;
case "JobTitle":
elem.BusinessPosition = notesItem.Text;
break;
case "WebSite":
elem.PersonalHomepage = notesItem.Text;
break;
//Address
case "PhoneNumber":
address.Phone = new PhoneNumber();
address.Phone.DenormalizedPhoneNumber = notesItem.Text;
break;
case "StreetAddress":
address.StreetName = notesItem.Text;
break;
case "State":
address.StateName = notesItem.Text;
break;
case "City":
address.CityName = notesItem.Text;
break;
case "Zip":
address.PostalCode = notesItem.Text;
break;
case "country":
address.CountryName = notesItem.Text;
break;
//Mobile
case "CellPhoneNumber":
elem.PersonalPhoneMobile = new PhoneNumber();
elem.PersonalPhoneMobile.DenormalizedPhoneNumber = notesItem.Text;
break;
//Categories
case "Categories":
elem.Categories = new List <string>(notesItem.Text.Split(';'));
break;
}
}
this.LogProcessingEvent("mapping contact {0} ...", elem.Name.ToString());
result.Add(elem);
}
this.ThinkTime(1000);
result.Sort();
}
}
catch (Exception ex)
{
this.LogProcessingEvent(
string.Format(CultureInfo.CurrentCulture, Resources.uiErrorAtName, currentElementName, ex.Message));
}
finally
{
//outlookNamespace.Logoff();
_lotesNotesSession = null;
}
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="Node"/> class.
/// </summary>
/// <param name="stdContact"> The <see cref="StdContact"/> to generate the node for. </param>
/// <param name="category"> The category for this node. </param>
public Node(StdContact stdContact, string category)
: this(stdContact as StdElement)
{
this.Category = category;
}