@Override
public ImportResult importItem(UUID jobId,
    IdempotentImportExecutor idempotentExecutor,
    TokensAndUrlAuthData authData, ContactsModelWrapper data) throws Exception{
  JCardReader reader = new JCardReader(data.getVCards());
  try {
    // TODO(olsona): address any other problems that might arise in conversion
    List<VCard> vCardList = reader.readAll();
    PeopleService.People peopleService = getOrCreatePeopleService(authData).people();
    for (VCard vCard : vCardList) {
      Person person = convert(vCard);
      idempotentExecutor.executeAndSwallowIOExceptions(
          vCard.toString(),
          vCard.getFormattedName().toString(),
          () -> peopleService.createContact(person).execute().toPrettyString());
    }
    return ImportResult.OK;
  } catch (IOException e) {
    return new ImportResult(e);
  }
}
 

@Test
public void importFirstResources() throws Exception {
  // Set up: small number of VCards to be imported
  int numberOfVCards = 5;
  List<VCard> vCardList = new LinkedList<>();
  for (int i = 0; i < numberOfVCards; i++) {
    StructuredName structuredName = new StructuredName();
    structuredName.setFamily("Family" + i);
    structuredName.setParameter(SOURCE_PARAM_NAME_TYPE, CONTACT_SOURCE_TYPE);
    VCard vCard = new VCard();
    vCard.setStructuredName(structuredName);
    vCard.setFormattedName("First " + structuredName.getFamily());
    vCardList.add(vCard);
  }
  String vCardString = GoogleContactsExporter.makeVCardString(vCardList);
  ContactsModelWrapper wrapper = new ContactsModelWrapper(vCardString);

  // Run test
  contactsService.importItem(UUID.randomUUID(), executor,null, wrapper);

  // Check that the right methods were called
  verify(people, times(numberOfVCards)).createContact(any(Person.class));
  verify(createContact, times(numberOfVCards)).execute();
}
 

public void importAllContact(Long id, List<Person> people) {
  int i = 0;
  SyncContact syncContact = syncContactRepo.find(id);
  if (syncContact == null) {
    return;
  }
  SyncContactHistoric syncContactHistoric = new SyncContactHistoric();
  for (Person googlePerson : people) {
    Partner partner = importContact(googlePerson, syncContact.getUpdateContactField());
    if (partner != null) {
      syncContactHistoric.addPartnerSetItem(partner);
    }
    if (i % 10 == 0) {
      JPA.clear();
    }
    i++;
  }
  updateSyncContact(id, syncContactHistoric);
}
 

@Transactional(rollbackOn = {AxelorException.class, Exception.class})
public Partner importContact(Person googlePerson, Boolean updateContactField) {
  if (googlePerson.getNames() == null) {
    return null;
  }
  Name nameGoogle = Mapper.toBean(Name.class, googlePerson.getNames().get(0));
  if (Strings.isStringEmpty(nameGoogle.getFamilyName())) {
    return null;
  }
  nameGoogle.setFamilyName(nameGoogle.getFamilyName().trim());
  String query = "self.name = '" + nameGoogle.getFamilyName() + "' ";
  if (!Strings.isStringEmpty(nameGoogle.getGivenName())) {
    nameGoogle.setGivenName(nameGoogle.getGivenName().trim());
    query += " AND self.firstName = '" + nameGoogle.getGivenName() + "' ";
  }
  Partner partner = partnerRepo.all().filter(query).fetchOne();
  if (partner == null) {
    partner = createPartner(googlePerson, nameGoogle);
  } else {
    partner = updatePartner(googlePerson, partner, updateContactField);
  }
  importCompany(googlePerson, partner, updateContactField);
  return partner;
}
 

protected void importPhoneNumber(
    Person googlePerson, Partner partner, Boolean updateContactField) {
  if (googlePerson.getPhoneNumbers() == null) {
    return;
  }
  PhoneNumber googleNumb =
      Mapper.toBean(PhoneNumber.class, googlePerson.getPhoneNumbers().get(0));
  if (!Strings.isStringEmpty(googleNumb.getCanonicalForm())) {
    if (partner.getMobilePhone() == null) {
      partner.setMobilePhone(googleNumb.getCanonicalForm().trim());
    } else {
      if (!partner.getMobilePhone().equals(googleNumb.getCanonicalForm().trim())) {
        if (updateContactField) {
          updateDescription(
              partner, I18n.get(SYNC_CONTACT_OLD_PHONE_NUMB), partner.getMobilePhone());
          partner.setMobilePhone(googleNumb.getCanonicalForm().trim());
        } else {
          updateDescription(
              partner,
              I18n.get(SYNC_CONTACT_GOOGLE_PHONE_NUMB),
              googleNumb.getCanonicalForm().trim());
        }
      }
    }
  }
}
 

protected void importCompany(Person googlePerson, Partner partner, Boolean updateContactField) {
  if (googlePerson.getOrganizations() == null) {
    return;
  }
  Organization googleCompany =
      Mapper.toBean(Organization.class, googlePerson.getOrganizations().get(0));
  if (!Strings.isStringEmpty(googleCompany.getName())) {
    Company company = companyRepo.findByName(googleCompany.getName().trim());
    if (company == null) {
      updateDescription(partner, I18n.get(SYNC_CONTACT_COMPANY), googleCompany.getName());
    } else if (partner.getCompanySet() == null
        || (partner.getCompanySet() != null && !partner.getCompanySet().contains(company))) {
      if (company.getPartner() != null) {
        if (partner.getMainPartner() == null) {
          partner.setMainPartner(company.getPartner());
        }
        company.getPartner().addContactPartnerSetItem(partner);
      }
      partner.addCompanySetItem(company);
    }
  }
  importJobTitle(partner, updateContactField, googleCompany);
}
 

@VisibleForTesting
static Person convert(VCard vCard) {
  Person person = new Person();

  Preconditions.checkArgument(atLeastOneNamePresent(vCard), "At least one name must be present");
  person.setNames(Collections.singletonList(getPrimaryGoogleName(vCard.getStructuredNames())));
  // TODO(olsona): nicknames for other source-typed names?
  // TODO(olsona): can we *actually* add more than one name?
  // No two names from the same source can be uploaded, and only names with source type CONTACT
  // can be uploaded, but what about names with source type null?

  if (vCard.getAddresses() != null) {
    person.setAddresses(
        vCard
            .getAddresses()
            .stream()
            .map(GoogleContactsImporter::convertToGoogleAddress)
            .collect(Collectors.toList()));
  }

  if (vCard.getTelephoneNumbers() != null) {
    person.setPhoneNumbers(
        vCard
            .getTelephoneNumbers()
            .stream()
            .map(GoogleContactsImporter::convertToGooglePhoneNumber)
            .collect(Collectors.toList()));
  }

  if (vCard.getEmails() != null) {
    person.setEmailAddresses(
        vCard
            .getEmails()
            .stream()
            .map(GoogleContactsImporter::convertToGoogleEmail)
            .collect(Collectors.toList()));
  }

  return person;
}
 

@VisibleForTesting
static VCard convert(Person person) {
  VCard vCard = new VCard();

  /* Reluctant to set the VCard.Kind value, since a) there aren't that many type options for
  Google contacts,
  b) those type options are often wrong, and c) those type options aren't even reliably in the
  same place.
  Source: https://developers.google.com/people/api/rest/v1/people#personmetadata
  */

  Preconditions.checkArgument(
      atLeastOneNamePresent(person.getNames()), "At least one name must be present");
  convertToVCardNamesAndPopulate(vCard, person.getNames());

  if (person.getAddresses() != null) {
    // VCard API does not support adding multiple addresses at once
    person.getAddresses().forEach(a -> vCard.addAddress(convertToVCardAddress(a)));
  }

  if (person.getPhoneNumbers() != null) {
    // VCard API does not support adding multiple telephone numbers at once
    person.getPhoneNumbers().forEach(n -> vCard.addTelephoneNumber(convertToVCardTelephone(n)));
  }

  if (person.getEmailAddresses() != null) {
    // VCard API does not support adding multiple emails at once
    person.getEmailAddresses().forEach(e -> vCard.addEmail(convertToVCardEmail(e)));
  }

  return vCard;
}
 

@Test
public void testConversionToVCardTelephone() {
  // Set up test: person with 2 primary phone numbers and 1 secondary phone number
  String primaryValue1 = "334-844-4244";
  String primaryValue2 = "411";
  String secondaryValue = "(555) 867-5309";
  PhoneNumber primaryPhone1 =
      new PhoneNumber().setValue(primaryValue1).setMetadata(PRIMARY_FIELD_METADATA);
  PhoneNumber primaryPhone2 =
      new PhoneNumber().setValue(primaryValue2).setMetadata(PRIMARY_FIELD_METADATA);
  PhoneNumber secondaryPhone =
      new PhoneNumber().setValue(secondaryValue).setMetadata(SECONDARY_FIELD_METADATA);
  Person person =
      DEFAULT_PERSON.setPhoneNumbers(Arrays.asList(secondaryPhone, primaryPhone1, primaryPhone2));

  // Run test
  VCard vCard = GoogleContactsExporter.convert(person);

  // Check results for correct values and preferences
  List<Telephone> resultPrimaryPhoneList =
      getPropertiesWithPreference(vCard, Telephone.class, VCARD_PRIMARY_PREF);
  assertThat(getValuesFromProperties(resultPrimaryPhoneList, Telephone::getText))
      .containsExactly(primaryValue1, primaryValue2);
  List<Telephone> resultSecondaryPhoneList =
      getPropertiesWithPreference(vCard, Telephone.class, VCARD_PRIMARY_PREF + 1);
  assertThat(getValuesFromProperties(resultSecondaryPhoneList, Telephone::getText))
      .containsExactly(secondaryValue);
}
 

@Test
public void testConversionToVCardEmail() {
  // Set up test: person with 1 primary email and 2 secondary emails
  String primaryString = "[email protected]";
  String secondaryString1 = "[email protected]";
  String secondaryString2 = "[email protected]";
  EmailAddress primaryEmail =
      new EmailAddress().setValue(primaryString).setMetadata(PRIMARY_FIELD_METADATA);
  EmailAddress secondaryEmail1 =
      new EmailAddress().setValue(secondaryString1).setMetadata(SECONDARY_FIELD_METADATA);
  EmailAddress secondaryEmail2 =
      new EmailAddress().setValue(secondaryString2).setMetadata(SECONDARY_FIELD_METADATA);
  Person person =
      DEFAULT_PERSON.setEmailAddresses(
          Arrays.asList(
              secondaryEmail1,
              primaryEmail,
              secondaryEmail2)); // Making sure order isn't a factor

  // Run test - NB, this Person only has emails
  VCard vCard = GoogleContactsExporter.convert(person);

  // Check results for correct values and preferences
  List<Email> resultPrimaryEmailList =
      getPropertiesWithPreference(vCard, Email.class, VCARD_PRIMARY_PREF);
  assertThat(getValuesFromTextProperties(resultPrimaryEmailList)).containsExactly(primaryString);
  List<Email> resultSecondaryEmailList =
      getPropertiesWithPreference(vCard, Email.class, VCARD_PRIMARY_PREF + 1);
  assertThat(getValuesFromTextProperties(resultSecondaryEmailList))
      .containsExactly(secondaryString1, secondaryString2);
}
 

@Before
public void setup() throws IOException {
  people = mock(People.class);
  peopleService = mock(PeopleService.class);
  createContact = mock(CreateContact.class);

  contactsService = new GoogleContactsImporter(peopleService);
  executor = new FakeIdempotentImportExecutor();

  when(peopleService.people()).thenReturn(people);
  when(people.createContact(any(Person.class))).thenReturn(createContact);

  Person person = new Person();
  when(createContact.execute()).thenReturn(person);
}
 

protected void onConnectionsLoadFinished(@Nullable List<Person> connections) {
    hideProgressDialog();

    if (connections == null) {
        Log.d(TAG, "getContacts:connections: null");
        mDetailTextView.setText(getString(R.string.connections_fmt, "None"));
        return;
    }

    Log.d(TAG, "getContacts:connections: size=" + connections.size());

    // Get names of all connections
    StringBuilder msg = new StringBuilder();
    for (int i = 0; i < connections.size(); i++) {
        Person person = connections.get(i);
        if (person.getNames() != null && person.getNames().size() > 0) {
            msg.append(person.getNames().get(0).getDisplayName());

            if (i < connections.size() - 1) {
                msg.append(",");
            }
        }
    }

    // Display names
    mDetailTextView.setText(getString(R.string.connections_fmt, msg.toString()));
}
 

@Override
protected List<Person> doInBackground(Account... accounts) {
    if (mActivityRef.get() == null) {
        return null;
    }

    Context context = mActivityRef.get().getApplicationContext();
    try {
        GoogleAccountCredential credential = GoogleAccountCredential.usingOAuth2(
                context,
                Collections.singleton(CONTACTS_SCOPE));
        credential.setSelectedAccount(accounts[0]);

        PeopleService service = new PeopleService.Builder(HTTP_TRANSPORT, JSON_FACTORY, credential)
                .setApplicationName("Google Sign In Quickstart")
                .build();

        ListConnectionsResponse connectionsResponse = service
                .people()
                .connections()
                .list("people/me")
                .setFields("names,emailAddresses")
                .execute();

        return connectionsResponse.getConnections();

    } catch (UserRecoverableAuthIOException recoverableException) {
        if (mActivityRef.get() != null) {
            mActivityRef.get().onRecoverableAuthException(recoverableException);
        }
    } catch (IOException e) {
        Log.w(TAG, "getContacts:exception", e);
    }

    return null;
}
 

@Override
protected void onPostExecute(List<Person> people) {
    super.onPostExecute(people);
    if (mActivityRef.get() != null) {
        mActivityRef.get().onConnectionsLoadFinished(people);
    }
}
 

public Partner createPartner(Person googlePerson, Name googleName) {
  Partner partner = new Partner();
  setDefaultPartnerValue(partner);
  importName(googleName, partner);
  importEmailAddress(googlePerson, partner, true);
  importAddress(googlePerson, partner, true);
  importPhoneNumber(googlePerson, partner, true);
  return partnerRepo.save(partner);
}
 

@Transactional(rollbackOn = {AxelorException.class, Exception.class})
public Partner updatePartner(Person googlePerson, Partner partner, Boolean updateContactField) {
  Boolean toUpdate =
      updateContactField
          && partner.getIsContact()
          && !partner.getIsCustomer()
          && !partner.getIsSupplier();
  updatePartnerFields(googlePerson, partner, toUpdate);
  return partnerRepo.save(partner);
}
 

private ExportResult<ContactsModelWrapper> exportContacts(
    TokensAndUrlAuthData authData, Optional<PaginationData> pageData) {
  try {
    // Set up connection
    Connections.List connectionsListRequest =
        getOrCreatePeopleService(authData).people().connections().list(SELF_RESOURCE);

    // Get next page, if we have a page token
    if (pageData.isPresent()) {
      StringPaginationToken paginationToken = (StringPaginationToken) pageData.get();
      connectionsListRequest.setPageToken(paginationToken.getToken());
    }

    // Get list of connections (nb: not a list containing full info of each Person)
    ListConnectionsResponse response =
        connectionsListRequest.setPersonFields(PERSON_FIELDS).execute();
    List<Person> peopleList = response.getConnections();

    // Get list of resource names, then get list of Persons
    List<String> resourceNames =
        peopleList.stream().map(Person::getResourceName).collect(Collectors.toList());
    GetPeopleResponse batchResponse =
        getOrCreatePeopleService(authData)
            .people()
            .getBatchGet()
            .setResourceNames(resourceNames)
            .setPersonFields(PERSON_FIELDS)
            .execute();
    List<PersonResponse> personResponseList = batchResponse.getResponses();

    // Convert Persons to VCards
    List<VCard> vCards =
        personResponseList.stream().map(a -> convert(a.getPerson())).collect(Collectors.toList());

    // Determine if there's a next page
    StringPaginationToken nextPageData = null;
    if (response.getNextPageToken() != null) {
      nextPageData = new StringPaginationToken(response.getNextPageToken());
    }
    ContinuationData continuationData = new ContinuationData(nextPageData);

    ContactsModelWrapper wrapper = new ContactsModelWrapper(makeVCardString(vCards));

    // Get result type
    ResultType resultType = ResultType.CONTINUE;
    if (nextPageData == null) {
      resultType = ResultType.END;
    }

    return new ExportResult<ContactsModelWrapper>(resultType, wrapper, continuationData);
  } catch (IOException e) {
    return new ExportResult<ContactsModelWrapper>(e);
  }
}
 

@Test
public void testConversionToVCardNames() {
  // Set up Person with a primary name and two secondary names
  String primaryGivenName = "Mark";
  String primaryFamilyName = "Twain";
  Name primaryName =
      new Name()
          .setGivenName(primaryGivenName)
          .setFamilyName(primaryFamilyName)
          .setMetadata(PRIMARY_FIELD_METADATA);

  String alternateGivenName1 = "Samuel";
  String alternateFamilyName1 = "Clemens";
  String alternateSourceType1 = "PROFILE";
  Name alternateName1 =
      new Name()
          .setGivenName(alternateGivenName1)
          .setFamilyName(alternateFamilyName1)
          .setMetadata(
              new FieldMetadata()
                  .setPrimary(false)
                  .setSource(new Source().setType(alternateSourceType1)));
  String alternateGivenName2 = "Louis";
  String alternateFamilyName2 = "de Conte";
  String alternateSourceType2 = "PEN_NAME";
  Name alternateName2 =
      new Name()
          .setGivenName(alternateGivenName2)
          .setFamilyName(alternateFamilyName2)
          .setMetadata(
              new FieldMetadata()
                  .setPrimary(false)
                  .setSource(new Source().setType(alternateSourceType2)));

  // Order shouldn't matter
  Person person =
      new Person().setNames(Arrays.asList(alternateName2, alternateName1, primaryName));

  // Run test
  VCard vCard = GoogleContactsExporter.convert(person);

  // Check name conversion correctness
  List<StructuredName> structuredNames = vCard.getStructuredNames();
  assertThat(structuredNames.size()).isEqualTo(3);

  // Check primary (non-alternate) names
  List<StructuredName> actualPrimaryNames =
      structuredNames.stream().filter(n -> n.getAltId() == null).collect(Collectors.toList());
  List<Pair<String, String>> actualPrimaryNamesValues =
      actualPrimaryNames
          .stream()
          .map(GoogleContactsExportConversionTest::getGivenAndFamilyNames)
          .collect(Collectors.toList());
  assertThat(actualPrimaryNamesValues)
      .containsExactly(Pair.of(primaryGivenName, primaryFamilyName));
  List<String> actualPrimarySourceValues =
      actualPrimaryNames
          .stream()
          .map(a -> a.getParameter(SOURCE_PARAM_NAME_TYPE))
          .collect(Collectors.toList());
  assertThat(actualPrimarySourceValues).containsExactly(DEFAULT_SOURCE_TYPE);

  // Check alternate names
  List<StructuredName> actualAlternateNames =
      structuredNames.stream().filter(n -> n.getAltId() != null).collect(Collectors.toList());
  List<Pair<String, String>> actualAlternateNamesValues =
      actualAlternateNames
          .stream()
          .map(GoogleContactsExportConversionTest::getGivenAndFamilyNames)
          .collect(Collectors.toList());
  assertThat(actualAlternateNamesValues)
      .containsExactly(
          Pair.of(alternateGivenName1, alternateFamilyName1),
          Pair.of(alternateGivenName2, alternateFamilyName2));
  List<String> actualAlternateSourceValues =
      actualAlternateNames
          .stream()
          .map(a -> a.getParameter(SOURCE_PARAM_NAME_TYPE))
          .collect(Collectors.toList());
  assertThat(actualAlternateSourceValues)
      .containsExactly(alternateSourceType1, alternateSourceType2);
}
 

@Test
public void testConversionToVCardAddress() {
  // Set up test: person with a primary address and a secondary address
  String primaryStreet = "221B Baker St";
  String primaryCity = "London";
  String primaryPostcode = "NW1";
  String primaryCountry = "United Kingdom";
  com.google.api.services.people.v1.model.Address primaryAddress =
      new com.google.api.services.people.v1.model.Address()
          .setStreetAddress(primaryStreet)
          .setCity(primaryCity)
          .setPostalCode(primaryPostcode)
          .setCountry(primaryCountry)
          .setMetadata(PRIMARY_FIELD_METADATA);

  String altStreet = "42 Wallaby Way";
  String altCity = "Sydney";
  String altRegion = "New South Wales";
  String altCountry = "Australia";
  com.google.api.services.people.v1.model.Address altAddress =
      new com.google.api.services.people.v1.model.Address()
          .setStreetAddress(altStreet)
          .setCity(altCity)
          .setRegion(altRegion)
          .setCountry(altCountry)
          .setMetadata(SECONDARY_FIELD_METADATA);

  Person person = DEFAULT_PERSON.setAddresses(Arrays.asList(altAddress, primaryAddress));

  // Run test
  VCard vCard = GoogleContactsExporter.convert(person);

  // Check results for correct values and preferences
  List<Address> actualPrimaryAddressList =
      getPropertiesWithPreference(vCard, Address.class, VCARD_PRIMARY_PREF);
  assertThat(
      actualPrimaryAddressList
          .stream()
          .map(Address::getStreetAddress)
          .collect(Collectors.toList()))
      .containsExactly(primaryStreet);
  List<Address> actualAltAddressList =
      getPropertiesWithPreference(vCard, Address.class, VCARD_PRIMARY_PREF + 1);
  assertThat(actualAltAddressList.stream().map(Address::getRegion).collect(Collectors.toList()))
      .containsExactly(altRegion);
}
 

@Test
public void testConversionToGoogleNames() {
  // Set up vCard with a primary name and one secondary name
  String primaryGivenName = "Mark";
  String primaryFamilyName = "Twain";
  String primarySourceType = "CONTACT";
  StructuredName primaryName =
      makeStructuredName(primaryGivenName, primaryFamilyName, primarySourceType);

  String altGivenName = "Samuel";
  String altFamilyName = "Clemens";
  String altSourceType = "PROFILE";
  StructuredName altName = makeStructuredName(altGivenName, altFamilyName, altSourceType);

  VCard vCard = new VCard();
  vCard.addProperty(primaryName);
  vCard.addPropertyAlt(StructuredName.class, Collections.singleton(altName));

  // Run test
  Person person = GoogleContactsImporter.convert(vCard);

  // Check results
  // Correct number of names
  assertThat(person.getNames().size()).isEqualTo(1);

  // Check primary names
  List<Name> actualPrimaryNames =
      person
          .getNames()
          .stream()
          .filter(a -> a.getMetadata().getPrimary())
          .collect(Collectors.toList());
  List<Pair<String, String>> actualPrimaryNameValues =
      actualPrimaryNames
          .stream()
          .map(GoogleContactsImportConversionTest::getGivenAndFamilyValues)
          .collect(Collectors.toList());
  assertThat(actualPrimaryNameValues)
      .containsExactly(Pair.of(primaryGivenName, primaryFamilyName));
  List<String> actualPrimaryNameSourceValues =
      actualPrimaryNames
          .stream()
          .map(a -> a.getMetadata().getSource().getType())
          .collect(Collectors.toList());
  assertThat(actualPrimaryNameSourceValues).containsExactly(primarySourceType);

  // Check secondary names - there shouldn't be any
  List<Name> actualSecondaryNames =
      person
          .getNames()
          .stream()
          .filter(a -> !a.getMetadata().getPrimary())
          .collect(Collectors.toList());
  assertThat(actualSecondaryNames).isEmpty();
}
 

@Test
public void testConversionToGoogleAddresses() {
  // Set up vCard with a primary address and a secondary address
  String primaryStreet = "221B Baker St";
  String primaryLocality = "London";
  ezvcard.property.Address primaryAddress = new ezvcard.property.Address();
  primaryAddress.setStreetAddress(primaryStreet);
  primaryAddress.setLocality(primaryLocality);
  primaryAddress.setPref(VCARD_PRIMARY_PREF);

  String altStreet = "42 Wallaby Way";
  String altLocality = "Sydney";
  ezvcard.property.Address altAddress = new ezvcard.property.Address();
  altAddress.setStreetAddress(altStreet);
  altAddress.setLocality(altLocality);
  altAddress.setPref(VCARD_PRIMARY_PREF + 1);

  // Add addresses to vCard.  Order shouldn't matter.
  VCard vCard = defaultVCard;
  vCard.addAddress(primaryAddress);
  vCard.addAddress(altAddress);

  // Run test
  Person person = GoogleContactsImporter.convert(vCard);

  // Check results
  // Check correct number of addresses
  assertThat(person.getAddresses().size()).isEqualTo(2);

  // Check primary address
  List<Address> actualPrimaryAddresses =
      person
          .getAddresses()
          .stream()
          .filter(a -> a.getMetadata().getPrimary())
          .collect(Collectors.toList());
  List<String> actualPrimaryAddressStreets =
      getValuesFromFields(actualPrimaryAddresses, Address::getStreetAddress);
  assertThat(actualPrimaryAddressStreets).containsExactly(primaryStreet);

  // Check secondary address
  List<Address> actualSecondaryAddresses =
      person
          .getAddresses()
          .stream()
          .filter(a -> !a.getMetadata().getPrimary())
          .collect(Collectors.toList());
  List<String> actualSecondaryAddressStreets =
      getValuesFromFields(actualSecondaryAddresses, Address::getStreetAddress);
  assertThat(actualSecondaryAddressStreets).containsExactly(altStreet);
}
 

@Test
public void testConversionToGooglePhones() {
  // Set up test: vCard with 2 primary phone numbers and 1 secondary phone number
  String primaryValue1 = "334-844-4244";
  String primaryValue2 = "411";
  String secondaryValue = "(555) 867-5309";
  Telephone primaryTelephone1 = new Telephone(primaryValue1);
  primaryTelephone1.setPref(VCARD_PRIMARY_PREF);
  Telephone primaryTelephone2 = new Telephone(primaryValue2);
  primaryTelephone2.setPref(VCARD_PRIMARY_PREF);
  Telephone secondaryTelephone = new Telephone(secondaryValue);
  secondaryTelephone.setPref(VCARD_PRIMARY_PREF + 1);

  // Add numbers to vCard.  Order shouldn't matter.
  VCard vCard = defaultVCard;
  vCard.addTelephoneNumber(secondaryTelephone);
  vCard.addTelephoneNumber(primaryTelephone1);
  vCard.addTelephoneNumber(primaryTelephone2);

  // Run test
  Person person = GoogleContactsImporter.convert(vCard);

  // Check results
  // Correct number of phone numbers
  assertThat(person.getPhoneNumbers().size()).isEqualTo(3);

  // Check primary phone numbers
  List<PhoneNumber> actualPrimaryNumbers =
      person
          .getPhoneNumbers()
          .stream()
          .filter(a -> a.getMetadata().getPrimary())
          .collect(Collectors.toList());
  List<String> actualPrimaryNumberStrings =
      getValuesFromFields(actualPrimaryNumbers, PhoneNumber::getValue);
  assertThat(actualPrimaryNumberStrings).containsExactly(primaryValue1, primaryValue2);

  // Check secondary phone numbers
  List<PhoneNumber> actualSecondaryNumbers =
      person
          .getPhoneNumbers()
          .stream()
          .filter(a -> !a.getMetadata().getPrimary())
          .collect(Collectors.toList());
  List<String> actualSecondaryNumberStrings =
      getValuesFromFields(actualSecondaryNumbers, PhoneNumber::getValue);
  assertThat(actualSecondaryNumberStrings).containsExactly(secondaryValue);
}
 

@Test
public void testConversionToGoogleEmails() {
  // Set up test: person with 1 primary email and 2 secondary emails
  String primaryString = "[email protected]";
  String secondaryString1 = "[email protected]";
  String secondaryString2 = "[email protected]";
  Email primaryEmail = new Email(primaryString);
  primaryEmail.setPref(VCARD_PRIMARY_PREF);
  Email secondaryEmail1 = new Email(secondaryString1);
  secondaryEmail1.setPref(VCARD_PRIMARY_PREF + 1);
  Email secondaryEmail2 = new Email(secondaryString2);
  secondaryEmail2.setPref(VCARD_PRIMARY_PREF + 1);

  // Add emails to vCard.  Order shouldn't matter.
  VCard vCard = defaultVCard;
  vCard.addEmail(secondaryEmail1);
  vCard.addEmail(primaryEmail);
  vCard.addEmail(secondaryEmail2);

  // Run test
  Person person = GoogleContactsImporter.convert(vCard);

  // Check results
  // Correct number of emails
  assertThat(person.getEmailAddresses().size()).isEqualTo(3);

  // Check primary email addresses
  List<EmailAddress> actualPrimaryEmails =
      person
          .getEmailAddresses()
          .stream()
          .filter(a -> a.getMetadata().getPrimary())
          .collect(Collectors.toList());
  List<String> actualPrimaryEmailsStrings =
      getValuesFromFields(actualPrimaryEmails, EmailAddress::getValue);
  assertThat(actualPrimaryEmailsStrings).containsExactly(primaryString);

  // Check secondary email addresses
  List<EmailAddress> actualSecondaryEmails =
      person
          .getEmailAddresses()
          .stream()
          .filter(a -> !a.getMetadata().getPrimary())
          .collect(Collectors.toList());
  List<String> actualSecondaryEmailsStrings =
      getValuesFromFields(actualSecondaryEmails, EmailAddress::getValue);
  assertThat(actualSecondaryEmailsStrings).containsExactly(secondaryString1, secondaryString2);
}
 

public List<Person> getPeople() {
  return people;
}
 

protected void importAddress(Person googlePerson, Partner partner, Boolean updateContactField) {
  if (googlePerson.getAddresses() == null) {
    return;
  }
  com.google.api.services.people.v1.model.Address googleAddr =
      Mapper.toBean(
          com.google.api.services.people.v1.model.Address.class,
          googlePerson.getAddresses().get(0));
  // Google contact has empty address or not enough fields to create an address
  if (Strings.isStringEmpty(googleAddr.getCountryCode())
      || Strings.isStringEmpty(googleAddr.getCountry())
      || Strings.isStringEmpty(googleAddr.getStreetAddress())
      || Strings.isStringEmpty(googleAddr.getPostalCode())) {
    return;
  }
  String query =
      "self.zip = '"
          + googleAddr.getPostalCode()
          + "' AND self.addressL7Country.alpha2Code = '"
          + googleAddr.getCountryCode()
          + "' AND self.addressL4 = '"
          + googleAddr.getStreetAddress()
          + "'";
  if (!Strings.isStringEmpty(googleAddr.getCity())) {
    query += " AND self.city.name = '" + googleAddr.getCity() + "'";
  }
  Address partnerAddr = addressRepo.all().filter(query).fetchOne();
  if (partnerAddr == null) {
    partnerAddr = createAddress(googleAddr);
  }
  if (partner.getMainAddress() == null) {
    partner.setMainAddress(partnerAddr);
    createPartnerAddress(partner, partnerAddr);
  } else {
    if (!partner.getMainAddress().equals(partnerAddr)) {
      if (updateContactField) {
        updateDescription(
            partner, I18n.get(SYNC_CONTACT_OLD_ADDR), partner.getMainAddress().getFullName());
        partner.setMainAddress(partnerAddr);
        createPartnerAddress(partner, partnerAddr);
      } else if (Strings.isStringEmpty(partner.getDescription())
          || (partner.getDescription() != null
              && !partner.getDescription().contains(googleAddr.getStreetAddress()))) {
        updateDescription(
            partner, I18n.get(SYNC_CONTACT_GOOGLE_ADDR), googleAddr.getFormattedValue());
      }
    }
  }
}
 

protected void updatePartnerFields(
    Person googlePerson, Partner partner, Boolean updateContactField) {
  importEmailAddress(googlePerson, partner, updateContactField);
  importAddress(googlePerson, partner, updateContactField);
  importPhoneNumber(googlePerson, partner, updateContactField);
}