@ordergroove/offers 2.28.9 → 2.28.11-alpha-PR-703-17.87

package/src/components/__tests__/PrepaidToggle.spec.js

@@ -0,0 +1,113 @@
+import { html, render } from 'lit-html';
+import { PrepaidToggle } from '../PrepaidToggle';
+
+const TEST_CONTAINER_ID = 'test-container';
+const TAG_NAME_UNDER_TEST = 'og-some-prepaid-toggle';
+customElements.define(TAG_NAME_UNDER_TEST, PrepaidToggle);
+
+async function renderTemplate(template) {
+  // make sure the element was cleaned up
+  expect(document.body.querySelector(TAG_NAME_UNDER_TEST)).toBeFalsy();
+  render(template, document.getElementById(TEST_CONTAINER_ID));
+  const element = document.querySelector(TAG_NAME_UNDER_TEST);
+  await element.updateComplete;
+  return element;
+}
+
+function getPrepaidToggleTemplate(options = [3, 6]) {
+  return html`
+    <og-some-prepaid-toggle product="yum product">
+      ${options.map(
+        opt =>
+          html`
+            <option value=${opt}></option>
+          `
+      )}
+    </og-some-prepaid-toggle>
+  `;
+}
+
+function expectPrepaidShipmentsAction(toggle, numShipments) {
+  expect(toggle.productChangePrepaidShipments).toHaveBeenCalledWith({ id: 'yum product' }, numShipments, undefined);
+  toggle.productChangePrepaidShipments.calls.reset();
+}
+
+function toggleCheckbox(checkbox) {
+  checkbox.checked = !checkbox.checked;
+  checkbox.dispatchEvent(new Event('change'));
+}
+
+function selectOption(ogSelect, value) {
+  const innerSelect = ogSelect.shadowRoot.querySelector('select');
+  innerSelect.value = value;
+  innerSelect.dispatchEvent(new Event('change'));
+}
+
+describe('PrepaidToggle', () => {
+  beforeEach(() => {
+    // create a dedicated container to render the templates into
+    // otherwise we get race conditions
+    const testContainer = document.createElement('div');
+    testContainer.id = TEST_CONTAINER_ID;
+    document.body.appendChild(testContainer);
+  });
+
+  afterEach(() => {
+    const testContainer = document.getElementById(TEST_CONTAINER_ID);
+    testContainer.remove();
+  });
+
+  it('should render with select options', async () => {
+    const toggle = await renderTemplate(getPrepaidToggleTemplate());
+
+    const select = toggle.shadowRoot.querySelector('og-select');
+    expect(select).toBeTruthy();
+    expect(select.options).toEqual([
+      { value: 3, text: '3 shipments' },
+      { value: 6, text: '6 shipments' }
+    ]);
+  });
+
+  it('should render static text when only one option', async () => {
+    const toggle = await renderTemplate(getPrepaidToggleTemplate([3]));
+    const select = toggle.shadowRoot.querySelector('og-select');
+    expect(select).toBeFalsy();
+    const label = toggle.shadowRoot.querySelector('label');
+    expect(label.innerText).toBe('Prepay for 3 shipments');
+  });
+
+  it('should opt into prepaid', async () => {
+    const toggle = await renderTemplate(getPrepaidToggleTemplate());
+    toggle.productChangePrepaidShipments = jasmine.createSpy('productChangePrepaidShipments');
+    const checkbox = toggle.shadowRoot.querySelector('input');
+
+    // checking checkbox selects default value
+    toggleCheckbox(checkbox);
+    expectPrepaidShipmentsAction(toggle, 3);
+
+    // changing select changes selection
+    const select = toggle.shadowRoot.querySelector('og-select');
+    selectOption(select, 6);
+    expectPrepaidShipmentsAction(toggle, 6);
+
+    // unchecking checkbox opts out of prepaid
+    toggleCheckbox(checkbox);
+    expectPrepaidShipmentsAction(toggle, null);
+
+    // checking checkbox again opts into previously selected value
+    toggleCheckbox(checkbox);
+    expectPrepaidShipmentsAction(toggle, 6);
+  });
+
+  it('should preselect a value if shipments is set', async () => {
+    const toggle = await renderTemplate(getPrepaidToggleTemplate());
+    toggle.shipments = 6;
+    await toggle.updateComplete;
+
+    const checkbox = toggle.shadowRoot.querySelector('input');
+    expect(checkbox.checked).toBe(true);
+
+    const select = toggle.shadowRoot.querySelector('og-select');
+    expect(select.selected).toBe(6);
+  });
+});

package/src/core/__tests__/descriptors.spec.js

@@ -228,3 +228,59 @@ describe('upcomingOrderContainsProduct', () => {
     ).toEqual(false);
   });
 });
+
+describe('prepaidEligible', () => {
+  it('should return false if no eligibilityGroups at all', () => {
+    expect(descriptors.prepaidEligible({}, ownProps)).toBe(false);
+  });
+
+  it('should return true if it has the prepaid group', () => {
+    expect(
+      descriptors.prepaidEligible(
+        {
+          eligibilityGroups: {
+            [productId]: ['prepaid']
+          }
+        },
+        ownProps
+      )
+    ).toBe(true);
+    expect(
+      descriptors.prepaidEligible(
+        {
+          eligibilityGroups: {
+            [productId]: []
+          }
+        },
+        ownProps
+      )
+    ).toBe(false);
+  });
+});
+
+function getPrepaidOptedinState(id, prepaidShipments) {
+  const frequency = '1_3';
+  return {
+    optedin: [
+      {
+        id,
+        frequency,
+        prepaidShipments
+      }
+    ]
+  };
+}
+
+describe('prepaidSubscribed', () => {
+  it('returns false when prepaidShipments is not set', () => {
+    expect(descriptors.prepaidSubscribed(getPrepaidOptedinState(productId, undefined), ownProps)).toBe(false);
+  });
+
+  it('returns true when prepaidShipments is set', () => {
+    expect(descriptors.prepaidSubscribed(getPrepaidOptedinState(productId, 3), ownProps)).toBe(true);
+  });
+
+  it('returns false when prepaidShipments is set for another product', () => {
+    expect(descriptors.prepaidSubscribed(getPrepaidOptedinState('otherProduct', 3), ownProps)).toBe(false);
+  });
+});

package/src/core/__tests__/reducer.spec.js

@@ -60,6 +60,85 @@ describe('reducers', () => {
         expect(actual).toEqual([{ id: 'product 3', frequency: '1_2' }]);
       });
 
+      it('should remove existing prepaidShipments given action PRODUCT_CHANGE_FREQUENCY', () => {
+        const actual = optedin(
+          [
+            {
+              id: productToTest.id,
+              frequency: '1_3',
+              prepaidShipments: 2
+            }
+          ],
+          {
+            type: constants.PRODUCT_CHANGE_FREQUENCY,
+            payload: {
+              product: productToTest,
+              frequency: '1_2'
+            }
+          }
+        );
+        expect(actual).toEqual([{ id: 'product 3', frequency: '1_2' }]);
+      });
+
+      it('should remove existing prepaidShipments given action OPTIN_PRODUCT', () => {
+        const actual = optedin(
+          [
+            {
+              id: productToTest.id,
+              frequency: '1_3',
+              prepaidShipments: 2
+            }
+          ],
+          {
+            type: constants.OPTIN_PRODUCT,
+            payload: {
+              product: productToTest,
+              frequency: '1_2'
+            }
+          }
+        );
+        expect(actual).toEqual([{ id: 'product 3', frequency: '1_2' }]);
+      });
+
+      it('should set prepaidShipments given action PRODUCT_CHANGE_PREPAID_SHIPMENTS', () => {
+        const actual = optedin(
+          [
+            {
+              id: productToTest.id,
+              frequency: '1_3'
+            }
+          ],
+          {
+            type: constants.PRODUCT_CHANGE_PREPAID_SHIPMENTS,
+            payload: {
+              product: productToTest,
+              prepaidShipments: 3
+            }
+          }
+        );
+        expect(actual).toEqual([{ id: 'product 3', frequency: '1_3', prepaidShipments: 3 }]);
+      });
+
+      it('should remove prepaidShipments given action PRODUCT_CHANGE_PREPAID_SHIPMENTS with null', () => {
+        const actual = optedin(
+          [
+            {
+              id: productToTest.id,
+              frequency: '1_3',
+              prepaidShipments: 3
+            }
+          ],
+          {
+            type: constants.PRODUCT_CHANGE_PREPAID_SHIPMENTS,
+            payload: {
+              product: productToTest,
+              prepaidShipments: null
+            }
+          }
+        );
+        expect(actual).toEqual([{ id: 'product 3', frequency: '1_3' }]);
+      });
+
       it('should return empty array given OPTOUT_PRODUCT', () => {
         const actual = optedin([], {
           type: constants.OPTOUT_PRODUCT,

package/src/core/actions.js

@@ -23,6 +23,11 @@ export const productChangeFrequency = (product, frequency, offer) => ({
   payload: { product, frequency, offer }
 });
 
+export const productChangePrepaidShipments = (product, prepaidShipments, offer) => ({
+  type: constants.PRODUCT_CHANGE_PREPAID_SHIPMENTS,
+  payload: { product, prepaidShipments, offer }
+});
+
 export const concludeUpsell = product => ({
   type: constants.CONCLUDE_UPSELL,
   payload: { product }

package/src/core/constants.js

@@ -1,6 +1,7 @@
 export const OPTIN_PRODUCT = 'OPTIN_PRODUCT';
 export const OPTOUT_PRODUCT = 'OPTOUT_PRODUCT';
 export const PRODUCT_CHANGE_FREQUENCY = 'PRODUCT_CHANGE_FREQUENCY';
+export const PRODUCT_CHANGE_PREPAID_SHIPMENTS = 'PRODUCT_CHANGE_PREPAID_SHIPMENTS';
 export const SET_MERCHANT_ID = 'SET_MERCHANT_ID';
 export const REQUEST_OFFER = 'REQUEST_OFFER';
 export const RECEIVE_OFFER = 'RECEIVE_OFFER';

package/src/core/descriptors.js

@@ -1,4 +1,4 @@
-import { makeSubscribedSelector, makeOptedoutSelector } from './selectors';
+import { makeSubscribedSelector, makeOptedoutSelector, makePrepaidSubscribedSelector } from './selectors';
 
 export const inStock = (state, ownProps) => (state.inStock || {})[(ownProps.product || {}).id];
 export const eligible = (state, ownProps) => (state.autoshipEligible || {})[(ownProps.product || {}).id] || false;
@@ -15,8 +15,14 @@ export const hasUpsellGroup = (state, ownProps) => {
   return groups === null || !!groups.find(it => it === 'upsell' || it === 'impulse_upsell');
 };
 
+export const prepaidEligible = (state, ownProps) => {
+  const groups = eligibilityGroups(state, ownProps);
+  return groups?.some(it => it === 'prepaid') || false;
+};
+
 export const subscribed = (state, ownProps) => makeSubscribedSelector(ownProps.product)(state);
 export const optedout = (state, ownProps) => makeOptedoutSelector(ownProps.product)(state);
+export const prepaidSubscribed = (state, ownProps) => makePrepaidSubscribedSelector(ownProps.product)(state);
 
 export const hasUpcomingOrder = state => !!(state.nextUpcomingOrder && state.nextUpcomingOrder.public_id);
 

package/src/core/reducer.js

@@ -3,7 +3,7 @@ import { combineReducers } from 'redux';
 import * as constants from './constants';
 import { isSameProduct } from './selectors';
 import { stringifyFrequency } from './api';
-import { safeProductId } from './utils';
+import { safeProductId, getMatchingProductIfExists } from './utils';
 
 export const optedin = (state = [], action) => {
   switch (action.type) {
@@ -12,16 +12,26 @@ export const optedin = (state = [], action) => {
     case constants.LOCAL_STORAGE_CHANGE:
       return action.newValue ? action.newValue.optedin : state;
     case constants.OPTIN_PRODUCT:
-    case constants.PRODUCT_CHANGE_FREQUENCY:
-      const [[oldone], rest] = state.reduce(
-        (acc, val) => acc[isSameProduct(action.payload.product, val) ? 0 : 1].push(val) && acc,
-        [[], []]
-      );
-      return (rest || []).concat({
+    case constants.PRODUCT_CHANGE_FREQUENCY: {
+      // since prepaid maps to a different set of frequencies, we remove prepaidShipments when frequency is changed
+      const [{ prepaidShipments, ...oldone }, rest] = getMatchingProductIfExists(state, action.payload.product);
+      return rest.concat({
         ...oldone,
         ...action.payload.product,
         frequency: action.payload.frequency
       });
+    }
+    case constants.PRODUCT_CHANGE_PREPAID_SHIPMENTS:
+      const { payload } = action;
+      const [{ prepaidShipments, ...oldone }, rest] = getMatchingProductIfExists(state, payload.product);
+      const newState = {
+        ...oldone,
+        ...payload.product
+      };
+      if (payload.prepaidShipments) {
+        newState.prepaidShipments = payload.prepaidShipments;
+      }
+      return rest.concat(newState);
     case constants.OPTOUT_PRODUCT:
       return state.filter(a => !isSameProduct(action.payload.product, a));
     case constants.PRODUCT_HAS_CHANGED:
@@ -47,11 +57,8 @@ export const optedout = (state = [], action) => {
     case constants.PRODUCT_CHANGE_FREQUENCY:
       return state.filter(a => !isSameProduct(action.payload.product, a));
     case constants.OPTOUT_PRODUCT:
-      const [[oldone], rest] = state.reduce(
-        (acc, val) => acc[isSameProduct(action.payload.product, val) ? 0 : 1].push(val) && acc,
-        [[], []]
-      );
-      return (rest || []).concat({
+      const [oldone, rest] = getMatchingProductIfExists(state, action.payload.product);
+      return rest.concat({
         ...oldone,
         ...action.payload.product,
         frequency: action.payload.frequency

package/src/core/selectors.js

@@ -99,6 +99,12 @@ export const makeSubscribedSelector = memoize(
   product => JSON.stringify(product)
 );
 
+export const makePrepaidSubscribedSelector = memoize(
+  product =>
+    createSelector(optedinSelector, optedin => optedin.some(b => isSameProduct(product, b) && b.prepaidShipments)),
+  product => JSON.stringify(product)
+);
+
 /**
  * Creates a function with state arguments that return the true when
  * productId is in the optedout array
@@ -114,6 +120,13 @@ export const makeProductFrequencySelector = memoize(productId =>
   createSelector(makeOptedinSelector(productId), productOptin => (productOptin && productOptin.frequency) || null)
 );
 
+export const makeProductPrepaidShipmentsSelector = memoize(productId =>
+  createSelector(
+    makeOptedinSelector(productId),
+    productOptin => (productOptin && productOptin.prepaidShipments) || null
+  )
+);
+
 /**
  * Creates a function with state arguments that returns stringified frequency
  * if default frequency exists for the product

package/src/core/utils.ts

@@ -1,5 +1,6 @@
 import platform from '../platform';
 import { ENV_PROD, ENV_STAGING, STAGING_STATIC_HOST, STATIC_HOST } from './constants';
+import { isSameProduct } from './selectors';
 
 export function onReady(fn) {
   if (document.readyState === 'loading') {
@@ -140,3 +141,18 @@ export function getOrCreateHidden(parent, name, value) {
     input.value = value;
   }
 }
+
+/**
+ * Returns the first matching product if it exists, or an empty object if it doesn't.
+ * @param state - the optedin/optedout state array to search
+ * @param product - the product to search for
+ * @returns {[any, any[]]} - a two item array where the first item is the matching product and the second is the remaining items from the original state.
+ */
+export function getMatchingProductIfExists(state, product) {
+  const [[oldone], rest] = state.reduce((acc, val) => acc[isSameProduct(product, val) ? 0 : 1].push(val) && acc, [
+    [],
+    []
+  ]);
+
+  return [oldone || {}, rest || []];
+}

package/src/make-api.js

@@ -20,6 +20,7 @@ import { Modal } from './components/Modal';
 import { Select } from './components/Select';
 import { Tooltip } from './components/Tooltip';
 import { ConnectedFrequencyStatus } from './components/FrequencyStatus';
+import { ConnectedPrepaidToggle } from './components/PrepaidToggle';
 import * as testMode from './test-mode';
 import { api } from './core/api';
 import { environment, offer } from './core/reducer';
@@ -51,6 +52,7 @@ export default function makeApi(store) {
     customElements.define('og-upsell-modal', ConnectedUpsellModal);
     customElements.define('og-next-upcoming-order', ConnectedNextUpcomingOrder);
     customElements.define('og-price', ConnectedPrice);
+    customElements.define('og-prepaid-toggle', ConnectedPrepaidToggle);
   } catch (err) {
     console.info('OG WebComponents already registered, skipping.');
   }

package/src/shopify/__tests__/shopifyReducer.spec.js

@@ -344,6 +344,45 @@ describe('config', () => {
     );
   });
 
+  it('should set prepaidSellingPlans', () => {
+    const sellingPlanGroups = [
+      {
+        name: 'Prepaid-43017264201944',
+        selling_plans: [
+          {
+            id: 2146042072,
+            name: 'Delivered every 2 months, prepaid for 4 shipments',
+            options: [
+              { name: 'Delivery every', position: 1, value: 'PREPAID-2 months' },
+              { name: 'Shipment amount', position: 2, value: '4 shipments' }
+            ]
+          }
+        ]
+      }
+    ];
+    const actual = config(
+      {},
+      {
+        type: constants.SETUP_PRODUCT,
+        payload: {
+          product: {
+            selling_plan_groups: sellingPlanGroups
+          }
+        }
+      }
+    );
+    expect(actual).toEqual({
+      prepaidSellingPlans: {
+        '43017264201944': [
+          {
+            numberShipments: 4,
+            sellingPlan: '2146042072'
+          }
+        ]
+      }
+    });
+  });
+
   it('should return unmodified state given unsupported action', () => {
     const actual = config(
       { 'yum existing key': 'yum existing value' },
@@ -1156,6 +1195,80 @@ describe('optedin', () => {
     });
   });
 
+  describe('given action is PRODUCT_CHANGE_PREPAID_SHIPMENTS', () => {
+    function getPayload(prepaidShipments) {
+      return {
+        product: {
+          id: 'yum prepaid id'
+        },
+        prepaidShipments: prepaidShipments,
+        offer: {
+          config: {
+            prepaidSellingPlans: {
+              'yum prepaid id': [
+                { numberShipments: 3, sellingPlan: 'yum prepaid selling plan id 1' },
+                {
+                  numberShipments: 4,
+                  sellingPlan: 'yum prepaid selling plan id 2'
+                }
+              ]
+            },
+            frequencies: ['yum selling plan id 1']
+          }
+        }
+      };
+    }
+
+    it('sets frequency to the corresponding selling plan', () => {
+      const actual = optedin([], {
+        type: constants.PRODUCT_CHANGE_PREPAID_SHIPMENTS,
+        payload: getPayload(4)
+      });
+      expect(actual).toEqual([
+        {
+          id: 'yum prepaid id',
+          frequency: 'yum prepaid selling plan id 2',
+          prepaidShipments: 4
+        }
+      ]);
+    });
+
+    it('sets frequency to the first frequency when prepaidShipments is null', () => {
+      const actual = optedin([], {
+        type: constants.PRODUCT_CHANGE_PREPAID_SHIPMENTS,
+        payload: getPayload(null)
+      });
+      expect(actual).toEqual([
+        {
+          id: 'yum prepaid id',
+          frequency: 'yum selling plan id 1'
+        }
+      ]);
+    });
+
+    it('updates existing opted in state', () => {
+      const actual = optedin(
+        [
+          {
+            id: 'yum prepaid id',
+            frequency: 'yum selling plan id 1'
+          }
+        ],
+        {
+          type: constants.PRODUCT_CHANGE_PREPAID_SHIPMENTS,
+          payload: getPayload(4)
+        }
+      );
+      expect(actual).toEqual([
+        {
+          id: 'yum prepaid id',
+          frequency: 'yum prepaid selling plan id 2',
+          prepaidShipments: 4
+        }
+      ]);
+    });
+  });
+
   it('should return unmodified state given unsupported action', () => {
     const actual = optedin(
       { 'yum existing key': 'yum existing value' },

package/src/shopify/shopifyMiddleware.ts

@@ -6,6 +6,7 @@ import {
   OPTIN_PRODUCT,
   OPTOUT_PRODUCT,
   PRODUCT_CHANGE_FREQUENCY,
+  PRODUCT_CHANGE_PREPAID_SHIPMENTS,
   RECEIVE_OFFER,
   REQUEST_OFFER,
   SETUP_CART,
@@ -340,6 +341,8 @@ export default function shopifyMiddleware(store) {
       case OPTOUT_PRODUCT:
       case PRODUCT_CHANGE_FREQUENCY:
         synchronizeCartOptin(action, store);
+      // eslint-disable-next-line no-fallthrough
+      case PRODUCT_CHANGE_PREPAID_SHIPMENTS:
       case REQUEST_OFFER:
       case RECEIVE_OFFER:
       case SETUP_PRODUCT:

package/src/shopify/shopifyReducer.js

@@ -28,7 +28,8 @@ import {
   hasShopifySellingPlans,
   isOgFrequency,
   mapFrequencyToSellingPlan,
-  safeProductId
+  safeProductId,
+  getMatchingProductIfExists
 } from '../core/utils';
 
 const money = val => (val === null ? '' : `$${val.toString().replace(/(\d\d)$/, '.$1')}`);
@@ -210,6 +211,22 @@ export function sellingPlansToFrequencies(sellingPlanGroup) {
   return sellingPlanGroup?.selling_plans?.map(({ id }) => `${id}`);
 }
 
+function getPrepaidSellingPlans(prepaidSellingPlanGroups) {
+  return prepaidSellingPlanGroups.reduce((acc, cur) => {
+    const variant = cur.name.split('-')[1];
+
+    const sellingPlanInfo = cur.selling_plans.map(sellingPlanObject => {
+      const shipments = sellingPlanObject?.options.find(({ name }) => name === 'Shipment amount')?.value.split(' ')[0];
+      return {
+        numberShipments: Number(shipments),
+        sellingPlan: String(sellingPlanObject.id)
+      };
+    });
+
+    return { ...acc, [variant]: sellingPlanInfo };
+  }, {});
+}
+
 export const config = (
   state = {
     frequencies: [],
@@ -236,8 +253,10 @@ export const config = (
     const {
       payload: { offer: offerEl, product }
     } = action;
+    let configToAdd = {};
+    // pay as you go selling plans
     const sellingPlanGroup = getOGSellingPlanGroup(product);
-    const frequencies = sellingPlanGroup?.selling_plans?.map(({ id }) => `${id}`);
+    const frequencies = sellingPlansToFrequencies(sellingPlanGroup);
     if (frequencies?.length) {
       const frequenciesEveryPeriod = sellingPlansToEveryPeriod(sellingPlanGroup);
       const frequenciesText = sellingPlanGroup.options?.[0]?.values || frequencies;
@@ -249,15 +268,26 @@ export const config = (
           getFirstSellingPlan(frequencies) ||
           defaultFrequency;
       }
-
-      return {
-        ...state,
-        frequenciesEveryPeriod,
+      configToAdd = {
         frequencies,
+        frequenciesEveryPeriod,
         frequenciesText,
         ...(defaultFrequency ? { defaultFrequency } : {})
       };
     }
+
+    // prepaid selling plans
+    const prepaidSellingPlanGroups = product?.selling_plan_groups.filter(group => /^Prepaid-.*/.test(group.name));
+    if (prepaidSellingPlanGroups.length) {
+      configToAdd = {
+        ...configToAdd,
+        prepaidSellingPlans: getPrepaidSellingPlans(prepaidSellingPlanGroups)
+      };
+    }
+    return {
+      ...state,
+      ...configToAdd
+    };
   }
 
   if (constants.RECEIVE_OFFER === action.type) {
@@ -310,6 +340,15 @@ export const inStock = (state = {}, action) => {
 
 export const offer = (state = {}, action) => state;
 
+function getFrequencyForPrepaidShipments({ prepaidShipments, offer: offerEl, product }) {
+  if (prepaidShipments) {
+    const productId = product.id;
+    const plan = offerEl.config.prepaidSellingPlans[productId]?.find(p => p.numberShipments === prepaidShipments);
+    return plan ? plan.sellingPlan : null;
+  }
+  return offerEl.config.frequencies[0];
+}
+
 export const optedin = (state = [], action) => {
   if (constants.SETUP_CART === action.type) {
     const cart = action.payload;
@@ -354,6 +393,19 @@ export const optedin = (state = [], action) => {
     });
   }
 
+  if (constants.PRODUCT_CHANGE_PREPAID_SHIPMENTS === action.type) {
+    const { payload } = action;
+    // core reducer sets prepaid shipments
+    const newState = coreOptedin(state, action);
+    // get the new frequency (selling plan) that matches the prepaid shipments
+    const [oldone, rest] = getMatchingProductIfExists(newState, payload.product);
+    return rest.concat({
+      ...oldone,
+      ...payload.product,
+      frequency: getFrequencyForPrepaidShipments(payload)
+    });
+  }
+
   return coreOptedin(state, action);
 };