Пример #1
0
    protected override void InitContactNonStandardProp(Contact contact, ContactProp prop, CsvRecordWrapper wrapper, int index)
    {
        Debug.Assert(wrapper[index] != null);

        switch ((AdditionalProp)prop)
        {
        case AdditionalProp.BusinessStreet2:
        case AdditionalProp.BusinessStreet3:
        {
            contact.Work ??= new Work();
            Address?adrWork = contact.Work.AddressWork;
            adrWork ??= new Address();
            contact.Work.AddressWork = adrWork;

            adrWork.Street += $" {(string?)wrapper[index]}";
        }
        break;

        case AdditionalProp.HomeStreet2:
        case AdditionalProp.HomeStreet3:
        {
            Address?adrHome = contact.AddressHome ?? new Address();
            contact.AddressHome = adrHome;

            adrHome.Street += $" {(string?)wrapper[index]}";
        }
        break;

        case AdditionalProp.AssistantsPhone:
        case AdditionalProp.BusinessPhone2:
        case AdditionalProp.CompanyMainPhone:
        {
            AddPhoneNumber(contact, new PhoneNumber((string?)wrapper[index], true));
        }
        break;

        case AdditionalProp.HomePhone2:
        case AdditionalProp.ISDN:
        case AdditionalProp.RadioPhone:
        case AdditionalProp.TTY_TDD_Phone:
        {
            AddPhoneNumber(contact, new PhoneNumber((string?)wrapper[index]));
        }
        break;

        case AdditionalProp.OtherFax:
        {
            AddPhoneNumber(contact, new PhoneNumber((string?)wrapper[index], isFax: true));
        }
        break;

        default:
            break;
        }
    }
Пример #2
0
    protected override void FillCsvRecordNonStandardProp(Contact contact, ContactProp prop, CsvRecordWrapper wrapper, int index)
    {
        switch ((AdditionalProp)prop)
        {
        case AdditionalProp.BusinessStreet2:
        case AdditionalProp.BusinessStreet3:
        case AdditionalProp.HomeStreet2:
        case AdditionalProp.HomeStreet3:
            break;

        case AdditionalProp.AssistantsPhone:
            wrapper[index] = GetValueFromPhone(contact.PhoneNumbers?.Where(x => x != null && x.IsWork && !x.IsFax), 2);
            break;

        case AdditionalProp.BusinessPhone2:
            wrapper[index] = GetValueFromPhone(contact.PhoneNumbers?.Where(x => x != null && x.IsWork && !x.IsFax), 3);
            break;

        case AdditionalProp.CompanyMainPhone:
            wrapper[index] = GetValueFromPhone(contact.PhoneNumbers?.Where(x => x != null && x.IsWork && !x.IsFax), 4);
            break;

        case AdditionalProp.HomePhone2:
            wrapper[index] = GetValueFromPhone(contact.PhoneNumbers?.Where(x => x != null && !x.IsWork && !x.IsFax), 7);

            break;

        case AdditionalProp.ISDN:
            wrapper[index] = GetValueFromPhone(contact.PhoneNumbers?.Where(x => x != null && !x.IsWork && !x.IsFax), 8);

            break;

        case AdditionalProp.RadioPhone:
            wrapper[index] = GetValueFromPhone(contact.PhoneNumbers?.Where(x => x != null && !x.IsWork && !x.IsFax), 9);

            break;

        case AdditionalProp.TTY_TDD_Phone:
            wrapper[index] = GetValueFromPhone(contact.PhoneNumbers?.Where(x => x != null && !x.IsWork && !x.IsFax), 10);

            break;

        case AdditionalProp.OtherFax:
            wrapper[index] = GetValueFromPhone(contact.PhoneNumbers?.Where(x => x != null && x.IsFax), 2);
            break;

        default:
            break;
        }
    }
Пример #3
0
    protected override void FillCsvRecordNonStandardProp(Contact contact, ContactProp prop, CsvRecordWrapper wrapper, int index)
    {
        switch ((AdditionalProp)prop)
        {
        case AdditionalProp.Phone1Type:
            wrapper[index] = GetTelephoneTypeFromPhone(contact.PhoneNumbers, 0);
            break;

        case AdditionalProp.Phone1Value:
            wrapper[index] = GetValueFromPhone(contact.PhoneNumbers, 0);
            break;

        case AdditionalProp.Phone2Type:
            wrapper[index] = GetTelephoneTypeFromPhone(contact.PhoneNumbers, 1);
            break;

        case AdditionalProp.Phone2Value:
            wrapper[index] = GetValueFromPhone(contact.PhoneNumbers, 1);
            break;

        case AdditionalProp.Phone3Type:
            wrapper[index] = GetTelephoneTypeFromPhone(contact.PhoneNumbers, 2);
            break;

        case AdditionalProp.Phone3Value:
            wrapper[index] = GetValueFromPhone(contact.PhoneNumbers, 2);
            break;

        case AdditionalProp.Phone4Type:
            wrapper[index] = GetTelephoneTypeFromPhone(contact.PhoneNumbers, 3);
            break;

        case AdditionalProp.Phone4Value:
            wrapper[index] = GetValueFromPhone(contact.PhoneNumbers, 3);
            break;

        case AdditionalProp.Phone5Type:
            wrapper[index] = GetTelephoneTypeFromPhone(contact.PhoneNumbers, 4);
            break;

        case AdditionalProp.Phone5Value:
            wrapper[index] = GetValueFromPhone(contact.PhoneNumbers, 4);
            break;

        case AdditionalProp.Phone6Type:
            wrapper[index] = GetTelephoneTypeFromPhone(contact.PhoneNumbers, 5);
            break;

        case AdditionalProp.Phone6Value:
            wrapper[index] = GetValueFromPhone(contact.PhoneNumbers, 5);
            break;

        case AdditionalProp.Phone7Type:
            wrapper[index] = GetTelephoneTypeFromPhone(contact.PhoneNumbers, 6);
            break;

        case AdditionalProp.Phone7Value:
            wrapper[index] = GetValueFromPhone(contact.PhoneNumbers, 6);
            break;

        case AdditionalProp.Phone8Type:
            wrapper[index] = GetTelephoneTypeFromPhone(contact.PhoneNumbers, 7);
            break;

        case AdditionalProp.Phone8Value:
            wrapper[index] = GetValueFromPhone(contact.PhoneNumbers, 7);
            break;

        case AdditionalProp.Phone9Type:
            wrapper[index] = GetTelephoneTypeFromPhone(contact.PhoneNumbers, 8);
            break;

        case AdditionalProp.Phone9Value:
            wrapper[index] = GetValueFromPhone(contact.PhoneNumbers, 8);
            break;

        case AdditionalProp.AddressHomeType:
            wrapper[index] = contact.AddressHome is null ? null : PropertyClassType.Home;
            break;

        case AdditionalProp.AddressWorkType:
            wrapper[index] = contact.Work?.AddressWork is null ? null : PropertyClassType.Work;
            break;

        case AdditionalProp.RelationType:
            if (contact.Person?.Spouse != null)
            {
                wrapper[index] = RelationType.Spouse;
            }
            break;

        case AdditionalProp.WebHomeType:
            wrapper[index] = PropertyClassType.Home;
            break;

        case AdditionalProp.WebWorkType:
            wrapper[index] = PropertyClassType.Work;
            break;

        case AdditionalProp.EventType:
        {
            DateTime?anniversary = contact.Person?.Anniversary;

            if (anniversary.HasValue)
            {
                wrapper[index] = EventType.Anniversary;
            }
        }
        break;

        case AdditionalProp.InstantMessenger1Type:
            wrapper[index] = contact.InstantMessengerHandles?.FirstOrDefault() ?? PropertyClassType.Other;
            break;

        case AdditionalProp.InstantMessenger1Service:
            wrapper[index] = GetIMService(contact.InstantMessengerHandles?.FirstOrDefault());
            break;

        case AdditionalProp.InstantMessenger2Type:
            wrapper[index] = contact.InstantMessengerHandles?.ElementAtOrDefault(1) is null ? null : PropertyClassType.Other;
            break;

        case AdditionalProp.InstantMessenger2Service:
            wrapper[index] = GetIMService(contact.InstantMessengerHandles?.ElementAtOrDefault(1));
            break;

        case AdditionalProp.Swap:
            // Dummy-Property ohne eigene Daten. Dient dazu AM ENDE der Initialsierung von CSVRecordWrapper
            // AddressWork AddressHome zuzuweisen, wenn AddressHome null war. (Google unterscheidet nur zwischen
            // Address 1 und Address 2 und weist diesen den Typ [Home | Work] explizit zu.)
            // Das gleiche gilt für HomePagePersonal und HomePageWork

            if (contact.AddressHome is null)
            {
                var adrWorkType = wrapper[nameof(ColumnName.AddressWorkType)];

                if (adrWorkType != null)
                {
                    wrapper[nameof(ColumnName.AddressHomeType)] = adrWorkType;
                    wrapper[nameof(ColumnName.AddressWorkType)] = null;

                    wrapper[nameof(ColumnName.AddressHomeStreet)] = wrapper[nameof(ColumnName.AddressWorkStreet)];
                    wrapper[nameof(ColumnName.AddressWorkStreet)] = null;

                    wrapper[nameof(ColumnName.AddressHomeCity)] = wrapper[nameof(ColumnName.AddressWorkCity)];
                    wrapper[nameof(ColumnName.AddressWorkCity)] = null;

                    wrapper[nameof(ColumnName.AddressHomePostalCode)] = wrapper[nameof(ColumnName.AddressWorkPostalCode)];
                    wrapper[nameof(ColumnName.AddressWorkPostalCode)] = null;

                    wrapper[nameof(ColumnName.AddressHomeState)] = wrapper[nameof(ColumnName.AddressWorkState)];
                    wrapper[nameof(ColumnName.AddressWorkState)] = null;

                    wrapper[nameof(ColumnName.AddressHomeCountry)] = wrapper[nameof(ColumnName.AddressWorkCountry)];
                    wrapper[nameof(ColumnName.AddressWorkCountry)] = null;
                }
            }

            if (contact.WebPagePersonal is null)
            {
                var webWorkType = wrapper[nameof(ColumnName.WebWorkType)];

                if (webWorkType != null)
                {
                    wrapper[nameof(ColumnName.WebHomeType)] = webWorkType;
                    wrapper[nameof(ColumnName.WebWorkType)] = null;

                    wrapper[nameof(ColumnName.WebHomeValue)] = wrapper[nameof(ColumnName.WebWorkValue)];
                    wrapper[nameof(ColumnName.WebWorkValue)] = null;
                }
            }
            break;

        default:
            break;
        }
    }
Пример #4
0
    protected override void InitContactNonStandardProp(Contact contact, ContactProp prop, CsvRecordWrapper wrapper, int index)
    {
        Debug.Assert(wrapper[index] != null);

        switch ((AdditionalProp)prop)
        {
        case AdditionalProp.Phone1Type:
        {
            var newNumber = new PhoneNumber();
            AddPhoneNumber(contact, newNumber);
            SetTelephoneType(newNumber, (string?)wrapper[index]);
        }
        break;

        case AdditionalProp.Phone2Type:
        case AdditionalProp.Phone3Type:
        case AdditionalProp.Phone4Type:
        case AdditionalProp.Phone5Type:
        case AdditionalProp.Phone6Type:
        case AdditionalProp.Phone7Type:
        case AdditionalProp.Phone8Type:
        case AdditionalProp.Phone9Type:
        {
            if (contact.PhoneNumbers is null)
            {
                contact.PhoneNumbers = new PhoneNumber();
            }

            PhoneNumber lastNumber = contact.PhoneNumbers.Last() !;


            if (lastNumber.IsEmpty)
            {
                SetTelephoneType(lastNumber, (string?)wrapper[index]);
            }
            else
            {
                var newNumber = new PhoneNumber();
                AddPhoneNumber(contact, newNumber);
                SetTelephoneType(newNumber, (string?)wrapper[index]);
            }
        }
        break;

        case AdditionalProp.Phone1Value:
        case AdditionalProp.Phone2Value:
        case AdditionalProp.Phone3Value:
        case AdditionalProp.Phone4Value:
        case AdditionalProp.Phone5Value:
        case AdditionalProp.Phone6Value:
        case AdditionalProp.Phone7Value:
        case AdditionalProp.Phone8Value:
        case AdditionalProp.Phone9Value:
        {
            if (contact.PhoneNumbers is null)
            {
                contact.PhoneNumbers = new PhoneNumber();
            }

            PhoneNumber lastNumber = contact.PhoneNumbers.Last() !;

            lastNumber.Value = (string?)wrapper[index];
        }
        break;

        //case AdditionalProp.AddressHomeType:
        //    break;
        //case AdditionalProp.AddressWorkType:
        //    break;
        //case AdditionalProp.InstantMessenger1Type:
        //    break;
        //case AdditionalProp.InstantMessenger1Service:
        //    break;
        //case AdditionalProp.InstantMessenger2Type:
        //    break;
        //case AdditionalProp.InstantMessenger2Service:
        //    break;
        //case AdditionalProp.RelationType:
        //    break;
        //case AdditionalProp.WebHomeType:
        //    break;
        //case AdditionalProp.WebWorkType:
        //    break;
        //case AdditionalProp.EventType:
        //    break;
        case AdditionalProp.Swap:     // diverse Aufräumarbeiten
        {
            // Swap Addresses:
            Address?addrHome = contact.AddressHome;
            Address?addrWork = contact.Work?.AddressWork;

#if NET40
            if (((string?)wrapper[nameof(ColumnName.AddressHomeType)])?.ToUpperInvariant().Contains(PropertyClassType.WorkUpperCase) ?? false)
#else
            if (((string?)wrapper[nameof(ColumnName.AddressHomeType)])?.Contains(PropertyClassType.Work, StringComparison.OrdinalIgnoreCase) ?? false)
#endif
            {
                Work?work = contact.Work ?? new Work();
                contact.Work = work;


                work.AddressWork    = addrHome;
                contact.AddressHome = null;

#if NET40
                if (!((string?)wrapper[nameof(ColumnName.AddressWorkType)])?.ToUpperInvariant().Contains(PropertyClassType.WorkUpperCase) ?? true)
#else
                if (!((string?)wrapper[nameof(ColumnName.AddressWorkType)])?.Contains(PropertyClassType.Work, StringComparison.OrdinalIgnoreCase) ?? true)
#endif
                {
                    contact.AddressHome = addrWork;
                }
            }

            Person?person = contact.Person;

            if (person != null)
            {
                // check RelationType
#if NET40
                if (!((string?)wrapper[nameof(ColumnName.RelationType)])?.ToUpperInvariant().Contains(RelationType.SpouseUpperCase) ?? true)
#else
                if (!((string?)wrapper[nameof(ColumnName.RelationType)])?.Contains(RelationType.Spouse, StringComparison.OrdinalIgnoreCase) ?? true)
#endif
                {
                    person.Spouse = null;
                }

                // check Anniversary
#if NET40
                if (!((string?)wrapper[nameof(ColumnName.EventType)])?.ToUpperInvariant().Contains(EventType.AnniversaryUpperCase) ?? true)
#else
                if (!((string?)wrapper[nameof(ColumnName.EventType)])?.Contains(EventType.Anniversary, StringComparison.OrdinalIgnoreCase) ?? true)
#endif
                {
                    Debug.Assert(contact.Person != null);
                    contact.Person.Anniversary = null;
                }
            }


            // swap Homepages

            var homePagePersonal = contact.WebPagePersonal;
            var homePageWork     = contact.WebPageWork;

#if NET40
            if (((string?)wrapper[nameof(ColumnName.WebHomeType)])?.ToUpperInvariant().Contains(PropertyClassType.WorkUpperCase) ?? false)
#else
            if (((string?)wrapper[nameof(ColumnName.WebHomeType)])?.Contains(PropertyClassType.Work, StringComparison.OrdinalIgnoreCase) ?? false)
#endif
            {
                contact.WebPageWork     = homePagePersonal;
                contact.WebPagePersonal = null;

#if NET40
                if (!((string?)wrapper[nameof(ColumnName.WebWorkType)])?.ToUpperInvariant().Contains(PropertyClassType.WorkUpperCase) ?? true)
#else
                if (!((string?)wrapper[nameof(ColumnName.WebWorkType)])?.Contains(PropertyClassType.Work, StringComparison.OrdinalIgnoreCase) ?? true)
#endif
                {
                    contact.WebPagePersonal = homePageWork;
                }
            }


            // Split CombinedValues

            var emails = (List <string>?)contact.EmailAddresses;

            if (emails != null)
            {
                for (int i = emails.Count - 1; i >= 0; i--)
                {
                    var currentEmail = emails[i];

                    if (!ContainsGoogleSeparator(currentEmail))
                    {
                        continue;
                    }

                    var arr = SplitAtGoogleSeparator(currentEmail);

                    if (arr.Length > 1)
                    {
                        emails.RemoveAt(i);

                        int j = 0;
                        while (j < arr.Length)
                        {
                            emails.Insert(i + j, arr[j]);
                            j++;
                        }
                    }
                }
            }

            var ims = (List <string>?)contact.InstantMessengerHandles;

            if (ims != null)
            {
                for (int i = ims.Count - 1; i >= 0; i--)
                {
                    var currentIms = ims[i];

                    if (!ContainsGoogleSeparator(currentIms))
                    {
                        continue;
                    }

                    var arr = SplitAtGoogleSeparator(currentIms);

                    if (arr.Length > 1)
                    {
                        ims.RemoveAt(i);

                        int j = 0;
                        while (j < arr.Length)
                        {
                            ims.Insert(i + j, arr[j]);
                            j++;
                        }
                    }
                }
            }

            IEnumerable <PhoneNumber?>?contactPhones = contact.PhoneNumbers;
            if (contactPhones != null && contactPhones.Any(x => x !.Value != null && ContainsGoogleSeparator(x.Value)))
            {
                List <PhoneNumber> phones;

                if (contactPhones is PhoneNumber pn)
                {
                    phones = new List <PhoneNumber>()
                    {
                        pn
                    };
                    contact.PhoneNumbers = phones;
                }
                else
                {
                    Debug.Assert(contactPhones is List <PhoneNumber>);
                    phones = (List <PhoneNumber>)contactPhones;
                }

                for (int i = phones.Count - 1; i >= 0; i--)
                {
                    PhoneNumber phone = phones[i];

                    string?phoneNumber = phone.Value;

                    if (phoneNumber != null && ContainsGoogleSeparator(phoneNumber))
                    {
                        string[] arr = SplitAtGoogleSeparator(phoneNumber);

                        if (arr.Length > 1)
                        {
                            phones.RemoveAt(i);

                            int j = 0;

                            while (j < arr.Length)
                            {
                                phone       = j == 0 ? phone : (PhoneNumber)phone.Clone();
                                phone.Value = arr[j];

                                phones.Insert(i + j, phone);
                                j++;
                            }
                        }
                    }
                }
            }
        }
        break;

        default:
            break;
        }
    }