This refinement details the necessary changes for the search by phone to work in admin tool documented in Search customer by phone in Admin App .
Solution 1
Create a phone lookup record in the commit order workflow. This will make sure that we’ll be able to find the customer searching by his phone as long as he has included it on the order, or registered in his account (verified or not). There are three possible scenarios:
Scenario | Condition | Outcome |
|---|---|---|
Delivery order | Phone number is mandatory to close the order | Creates record using the order’s phone number |
Not delivery order but user has a phone added to his account | Phone number is not mandatory | Creates record using the user’s account phone number if it doesn’t exist already |
Not delivery order and user hasn’t added a phone to his account | Phone number is not mandatory | Doesn’t create a record |
Pros and cons
Pros
Uses existing lookup record structure
Search will work with both phone numbers included in the order or the user account
This solution will be compatible with the Phone OTP
Doesn’t require phone verification
Doesn’t require migration scripts, the search will work as long as the user has made one order after the feature release
Cons
A phone number can only be associated with a single customer, which will be the first one to inform the number on the platform
There isn’t a simple way to delete the link between a user and a phone number recorded in a delivery order. One possibility is allowing customer support to remove the link via the support tool if it is outdated.
Implementation Proposal
Search by phone
The search will be implemented in the users service API, the NPM user package (represented as intl-packages below) exposes the client that admin app will use to make this request.
Create phone lookup records
The creation of the lookup records can be either synchronous or asynchronous, the two diagrams below details the different approaches:
asynchronous: since the commit order operation is already slow, this option minimizes possibly making it slower. [PREFERRED]
synchronous: simpler implementation
POC
The code below creates lookup records if they don’t exist when the order is committed.
intl-whitelabel-graphql/src/functions/graphql/resolvers/orders.ts
Mutation: {
async commitOrder(...) {
...
const savePhone = () => {
const phoneNumber = delivery?.dropoff?.phoneNumber ?? contextUser.details.phoneNumber;
const { cognitoId } = contextUser;
if (phoneNumber && cognitoId) {
providers.users.createPhoneRecord(cognitoId, phoneNumber);
}
};
savePhone();
}
}
intl-packages/src/user-lookup-by-phone/user-lookup-by-phone.ts
class UserLookupByPhone {
public async create({ cognitoId, phoneNumber }: { cognitoId: string; phoneNumber: string }) {
const params = {
ConditionExpression: INSERT_CONDITION_EXPRESSION,
Item: {
pk: `phone#${phoneNumber}`,
pk2: `phone_user#${cognitoId}`,
sk: 'v0_UserPhone',
sk2: 'v0_UserPhoneLookUp',
},
TableName: this.tableName,
};
await this.executeWithRetry(DynamoMethods.put, params);
}
public async getByUserServiceLookup(
phoneNumber: string,
): Promise<IUserLookupByPhone | undefined> {
const dynamoSearch = {
ExpressionAttributeValues: {
':pk': `phone#${phoneNumber}`,
':sk': 'v0_UserPhone',
},
KeyConditionExpression: 'pk = :pk AND begins_with(sk, :sk)',
TableName: this.tableName,
};
const { Items } = await this.executeWithRetry(DynamoMethods.query, dynamoSearch);
const Item = Items?.[0];
return Item ? cast(Item, TUserLookupByPhone) : undefined;
}
}
Commit an order with delivery.dropoff.phoneNumber +222222
Validate record in database
Searching phone in support tool
Customer details
Solution 2 [Preferred]
Solution 2 uses the same strategy as solution 1, the only difference is that it proposes to update the lookup record structure so that it can link multiple phone numbers to multiple customers. Below is a suggestion of the new record:
We’ll need to implement checks to prevent the creation of multiple lookup records linking the same phone number and customer
{
pk: `phone_user#${cognitoId}`,
pk2: `phone#${phoneNumber}`,
sk: `createdAt#${createdAt}`,
sk2: 'createdAt#${createdAt}',
}
With these changes, the search by phone will return a list of customers instead of a single one and avoid the problem of manual record deletion that solution 1 requires. However, the support tool front end will have to be adapted so that customer support can choose which one they want to check, given the list of customers associated with that phone number. The front end design will have to be aligned with UI/UX team.
An important point is that customer support can differentiate which customer is the actual owner of the phone number. Phone verification is not enabled in Iberia right now, but the feature is expected to be activated in the following months.
Pros and cons
Pros
Search will work with both phone numbers included in the order or in the user account
Doesn’t require phone verification
This solution will be compatible with the Phone OTP
Doesn’t require migration scripts, the search will work as long as the user has made one order after the feature release
Allows the association of multiple phone numbers with multiple customers
Cons
Require the development of a new page in the support tool front end to select which customer they want to check
Although very unlikely, there is a scenario where a single phone number is linked to many customers and this might make the process of finding the right one cumbersome
POC
SearchByPhone POC:
For this POC I changed the getByUserServiceLookup to use the proposed structure:
intl-packages/src/user-lookup-by-phone/user-lookup-by-phone.ts
public async getByUserServiceLookup(
phoneNumber: string,
): Promise<IUserLookupByPhone[] | undefined> {
const dynamoSearch = {
ExpressionAttributeValues: {
':pk2': `phone_lookup#${phoneNumber}`,
':sk2': 'createdAt#',
},
IndexName: 'brand-index-2',
KeyConditionExpression: 'pk2 = :pk2 AND begins_with(sk2, :sk2)',
TableName: this.tableName,
};
const { Items } = await this.executeWithRetry(DynamoMethods.query, dynamoSearch);
return Items ? Items.map((item) => cast(item, TUserLookupByPhone)) : undefined;
}
created 4 lookup records for 2 customers:
and was able to find the two customers when searching for the phone number +123123123:
Distinguish verified number POC:
To explicitly display which user is verified, we need to:
return phoneVerified in the Customer query from backend
check verified numbers and compare them with the searched text in the result.
intl-admin-app/src/components/layout/universal-search/index.tsx
export const UniversalSearch = () => {
...
return (
<List>
...
{searchResults.map((result) => {
const customer = result as CustomerDetails;
const { phoneVerified, phoneNumber } = customer;
const isVerifiedUser = !!phoneVerified && searchTerm === phoneNumber;
return (
<SearchItem
item={result}
key={result.id}
onClick={handleSearchResultSelection}
isVerified={isVerifiedUser}
/>
);
}
</List>
)
}
The code alterations above, plus altering SearchItem to change the text if the phone is verified we get:
Task breakdown
[intl-user-service]
Refactor user-lookup-by-phone.repository to use both “UserPhone” and “UserPhoneLookUp” records
Since this impacts SA team, we need to ask their review as well
Update the lookup record structure to enable associating multiple phones and users
Develop create lookup records endpoint
Develop find by phone endpoint
[intl-packages]
Develop a method in intl-users that creates lookup records in via the new user endpoint
Update the searchByPhone method to use the new User endpoint
[intl-whitelabel-graphql]
Create lookup records in commitOrder
[intl-fulfillment-service]
Create lookup records in commitOrder
[intl-admin-app]
Update customer query to also search by phone
Include search by phone in search bar
include search by phone in use-universal-search hook
add logic to explicitly show verified numbers
Add Comment