utils/address.js

/**
 * @namespace Utils
 * @category Utils
 * @module Address
 * */

/**
 * @example
 *  Input:
 *  getFormattedAddress({
 *  city: 'Montpellier'
 * })
 *  Output format: N°, Rue, Code postal, Commune
 *  Output: Montpellier
 *
 *  Input: {streetNumber: 340, streetName: 'Rue Fra Angelico', county:"Herault", country:"France"}, {country:true}
 *  Output format: N°, Rue, Code postal, Commune, Pays
 *  Output: 340, Rue Fra Angelico, Herault, France
 *
 * @param {*} item
 * @param {*} options
 * @returns
 */
export function getFormattedAddress(item, options = {}) {
  options.streetNumber = options.streetNumber || 'streetNumber'
  options.streetAddress =
    options.streetAddress ||
    options.streetName ||
    (!!item.street_name && 'street_name') ||
    (!!item.streetName && 'streetName') ||
    (!!item.street && 'street')
  options.zipCode =
    options.zipCode ||
    (!!item.zipcode && 'zipcode') ||
    (!!item.zipCode && 'zipCode')
  options.city =
    options.city || (!!item.city && 'city') || (!!item.city && 'county')

  const { streetNumber, streetAddress, zipCode, city, useZone, zone } = options
  if (useZone && item[zone]) {
    return item[zone] || ''
  }
  let r = `${(streetNumber && item[streetNumber]) || ''}`.trim()

  const getPropValue = (propName) => {
    if (propName && item[propName] && item[propName] !== 'NaN') {
      return item[propName]
    } else {
      return ''
    }
  }

  r = getPropValue(streetAddress)
    ? (r ? r + `, ` : r + ``) + getPropValue(streetAddress)
    : ''

  r = getPropValue(zipCode)
    ? (r ? r + `, ` : r + ``) + getPropValue(zipCode)
    : r

  r = getPropValue(city) ? (r ? r + `, ` : r + ``) + getPropValue(city) : r

  //options.country can be either true/false or a string (attribute name to pick country from)
  if (!!options.country && (!!item[options.country] || !!item.country)) {
    let countryFieldName =
      (!!item[options.country] && options.country) ||
      (!!item.country && 'country')
    r = item[countryFieldName]
      ? (r ? r + `, ` : r + ``) +
        ((countryFieldName && item[countryFieldName]) || '')
      : r
  }

  return r || ''
}

/**
 * @example
 * Response example: 
 *  {
        country: "France",
        street: "12 rue de test",
        postalcode: "44470",
        city: "Carquefou",
        state: "Carquefou"
    }
 */
export function normalizeApiAddressResponse(formFields) {
  let address = {}
  let addressStreet
  Object.keys(formFields).forEach((key) => {
    switch (key) {
      case 'country':
        address.country = formFields[key] ? formFields[key] : ''
        break
      case 'postal_code':
      case 'zipcode':
        address.postalcode = formFields[key] ? formFields[key] : ''
        break
      case 'department':
        address.state = formFields[key] ? formFields[key] : ''
        break
      case 'street_name':
      case 'street_number':
        if (formFields['street_number'] && formFields['street_name']) {
          addressStreet =
            formFields['street_number'] + ' ' + formFields['street_name']
        } else {
          addressStreet = ''
        }
        address.street = addressStreet
        break
      case 'streetName':
      case 'streetNumber':
        if (formFields['streetNumber'] && formFields['streetName']) {
          addressStreet =
            formFields['streetNumber'] + ' ' + formFields['streetName']
        } else {
          addressStreet = ''
        }
        address.street = addressStreet
        break

      case 'city':
      case 'county':
        address.city = formFields[key] ? formFields[key] : ''
        break
    }
  })

  return address
}

/**
 * @todo Refactor/Remove (It only works well with a result from normalizeApiAddressResponse)
 */
export function getFormattedAddressAlt(addressItem) {
  let formattedAddress = ''

  if (Object.keys(addressItem).length > 0) {
    Object.keys(addressItem).forEach((key) => {
      formattedAddress += ` ${addressItem[key]}`
    })
  }
  return formattedAddress.trim()
}