6468133945

Committed 10 Oct 2023 10:36AM UTC coverage: 40.778% (+0.7%) from 40.103%

Build # 6468133945

Build Type

Pull #2030

github

Committed by

juanmahidalgo

Commit Message

test: add Test for SearchBarDropdown

Pull Request Pull Request #2030: Feat: new search bar component

Run Details

2260 of 6951 branches covered (0.0%)

Branch coverage included in aggregate %.

215 of 215 new or added lines in 20 files covered. (100.0%)

4280 of 9087 relevant lines covered (47.1%)

18.0 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/webapp/src/modules/analytics/track.ts

import { PayloadAction } from 'typesafe-actions'
import { ethers } from 'ethers'
import {
  EventName,
  GetPayload
} from 'decentraland-dapps/dist/modules/analytics/types'
import {
  FETCH_TRANSACTION_FAILURE,
  FIX_REVERTED_TRANSACTION,
  REPLACE_TRANSACTION_SUCCESS,
  FetchTransactionFailureAction,
  FixRevertedTransactionAction,
  ReplaceTransactionSuccessAction
} from 'decentraland-dapps/dist/modules/transaction/actions'
import {
  GrantTokenSuccessAction,
  GRANT_TOKEN_SUCCESS,
  RevokeTokenSuccessAction,
  REVOKE_TOKEN_SUCCESS
} from 'decentraland-dapps/dist/modules/authorization/actions'
import { TransactionStatus } from 'decentraland-dapps/dist/modules/transaction/types'
import { add } from 'decentraland-dapps/dist/modules/analytics/utils'
import { capitalize } from '../../lib/text'
import {
  CREATE_ORDER_SUCCESS,
  CANCEL_ORDER_SUCCESS,
  EXECUTE_ORDER_TRANSACTION_SUBMITTED,
  CreateOrderSuccessAction,
  CancelOrderSuccessAction,
  ExecuteOrderTransactionSubmittedAction,
  ExecuteOrderWithCardSuccessAction,
  EXECUTE_ORDER_WITH_CARD_SUCCESS
} from '../order/actions'
import {
  TRANSFER_NFT_TRANSACTION_SUBMITTED,
  TransferNFTSuccessAction,
  FETCH_NFTS_SUCCESS,
  FetchNFTsSuccessAction
} from '../nft/actions'
import {
  PLACE_BID_SUCCESS,
  ACCEPT_BID_TRANSACTION_SUBMITTED,
  CANCEL_BID_SUCCESS,
  ARCHIVE_BID,
  UNARCHIVE_BID,
  PlaceBidSuccessAction,
  CancelBidSuccessAction,
  ArchiveBidAction,
  UnarchiveBidAction,
  AcceptBidTransactionSubmittedAction
} from '../bid/actions'
import {
  BuyItemSuccessAction,
  BuyItemWithCardSuccessAction,
  BUY_ITEM_SUCCESS,
  BUY_ITEM_WITH_CARD_SUCCESS,
  FetchItemsSuccessAction,
  FETCH_ITEMS_SUCCESS
} from '../item/actions'
import { SetIsTryingOnAction, SET_IS_TRYING_ON } from '../ui/preview/actions'
import { isParcel } from '../nft/utils'
import {
  AcceptRentalListingSuccessAction,
  ACCEPT_RENTAL_LISTING_SUCCESS,
  ClaimAssetSuccessAction,
  CLAIM_ASSET_SUCCESS,
  UpsertRentalSuccessAction,
  UPSERT_RENTAL_SUCCESS
} from '../rental/actions'
import { UpsertRentalOptType } from '../rental/types'
import { NFTCategory } from '@dcl/schemas'
import {
  SetPurchaseAction,
  SET_PURCHASE
} from 'decentraland-dapps/dist/modules/gateway/actions'
import { PurchaseStatus } from 'decentraland-dapps/dist/modules/gateway/types'
import * as events from '../../utils/events'
import {
  CREATE_LIST_FAILURE,
  CREATE_LIST_SUCCESS,
  CreateListFailureAction,
  CreateListSuccessAction,
  DELETE_LIST_FAILURE,
  DELETE_LIST_SUCCESS,
  DeleteListFailureAction,
  DeleteListSuccessAction,
  PICK_ITEM_FAILURE,
  PICK_ITEM_SUCCESS,
  PickItemFailureAction,
  PickItemSuccessAction,
  UNPICK_ITEM_FAILURE,
  UNPICK_ITEM_SUCCESS,
  UPDATE_LIST_FAILURE,
  UPDATE_LIST_SUCCESS,
  UnpickItemFailureAction,
  UnpickItemSuccessAction,
  UpdateListFailureAction,
  UpdateListSuccessAction
} from '../favorites/actions'
import { getCategoryInfo } from '../../utils/category'
import {
  FETCH_CREATORS_ACCOUNT_SUCCESS,
  FetchCreatorsAccountSuccessAction
} from '../account/actions'

function track<T extends PayloadAction<string, any>>(
  actionType: string,
  eventName: string | ((action: T) => string),
  getPayload = (action: T) => action.payload
) {
  add(actionType, eventName as EventName, getPayload as GetPayload)
}

function withCategory(eventName: string, item: { category: string }) {
  const category = capitalize(item.category)
  return `${eventName} ${category}`
}

track<ExecuteOrderTransactionSubmittedAction>(
  EXECUTE_ORDER_TRANSACTION_SUBMITTED,
  ({ payload }) => withCategory(events.BUY, payload.nft),
  ({ payload }) => ({
    category: payload.nft.category,
    nft: payload.nft.id,
    price: payload.order.price,
    seller: payload.order.owner,
    buyer: payload.order.buyer,
    ...getCategoryInfo(payload.nft)
  })
)

track<ExecuteOrderWithCardSuccessAction>(
  EXECUTE_ORDER_WITH_CARD_SUCCESS,
  ({ payload }) => withCategory(events.BUY_WITH_CARD, payload.nft),
  ({ payload }) => ({
    category: payload.nft.category,
    nft: payload.nft.id,
    price: payload.purchase.nft.cryptoAmount,
    seller: payload.nft.owner,
    buyer: payload.purchase.address
  })
)

track<CreateOrderSuccessAction>(
  CREATE_ORDER_SUCCESS,
  ({ payload }) => withCategory(events.PUBLISH, payload.nft),
  ({ payload }) => ({
    category: payload.nft.category,
    tokenId: payload.nft.tokenId,
    price: payload.price
  })
)

track<CancelOrderSuccessAction>(
  CANCEL_ORDER_SUCCESS,
  ({ payload }) => withCategory(events.CANCEL_SALE, payload.nft),
  ({ payload }) => ({
    category: payload.nft.category,
    tokenId: payload.nft.tokenId,
    price: payload.order.price
  })
)

track<TransferNFTSuccessAction>(
  TRANSFER_NFT_TRANSACTION_SUBMITTED,
  ({ payload }) => withCategory(events.TRANSFER_NFT, payload.nft),
  ({ payload }) => ({
    category: payload.nft.category,
    tokenId: payload.nft.tokenId,
    to: payload.address
  })
)

track<FetchTransactionFailureAction>(FETCH_TRANSACTION_FAILURE, ({ payload }) =>
  payload.status === TransactionStatus.REVERTED
    ? events.TRANSACTION_FAILED
    : events.TRANSACTION_DROPPED
)

track<FixRevertedTransactionAction>(
  FIX_REVERTED_TRANSACTION,
  events.TRANSACTION_FIXED
)

track<ReplaceTransactionSuccessAction>(
  REPLACE_TRANSACTION_SUCCESS,
  events.TRANSACTION_REPLACED
)

track<GrantTokenSuccessAction>(GRANT_TOKEN_SUCCESS, () => events.AUTHORIZE)

track<RevokeTokenSuccessAction>(REVOKE_TOKEN_SUCCESS, () => events.UNAUTHORIZE)

track<PlaceBidSuccessAction>(
  PLACE_BID_SUCCESS,
  ({ payload }) => withCategory(events.BID, payload.nft),
  ({ payload }) => ({
    category: payload.nft.category,
    tokenId: payload.nft.tokenId,
    price: payload.price,
    bidder: payload.bidder
  })
)

track<AcceptBidTransactionSubmittedAction>(
  ACCEPT_BID_TRANSACTION_SUBMITTED,
  events.ACCEPT_BID,
  ({ payload }) => ({
    tokenId: payload.bid.tokenId,
    bidId: payload.bid.id,
    bidder: payload.bid.bidder,
    seller: payload.bid.seller
  })
)

track<CancelBidSuccessAction>(
  CANCEL_BID_SUCCESS,
  events.CANCEL_BID,
  ({ payload }) => ({
    tokenId: payload.bid.tokenId,
    bidId: payload.bid.id,
    bidder: payload.bid.bidder
  })
)

track<ArchiveBidAction>(ARCHIVE_BID, events.ARCHIVE_BID, ({ payload }) => ({
  tokenId: payload.bid.tokenId,
  bidId: payload.bid.id,
  price: payload.bid.price
}))

track<UnarchiveBidAction>(
  UNARCHIVE_BID,
  events.UNARCHIVE_BID,
  ({ payload }) => ({
    tokenId: payload.bid.tokenId,
    bidId: payload.bid.id,
    price: payload.bid.price
  })
)

track<FetchNFTsSuccessAction>(
  FETCH_NFTS_SUCCESS,
  events.FETCH_NFTS,
  ({ payload }) => ({
    ...payload.options.params,
    view: payload.options.view,
    vendor: payload.options.vendor,
    count: payload.count
  })
)

track<FetchItemsSuccessAction>(
  FETCH_ITEMS_SUCCESS,
  events.FETCH_ITEMS,
  ({ payload }) => ({
    options: payload.options,
    total: payload.total
  })
)

track<BuyItemSuccessAction>(
  BUY_ITEM_SUCCESS,
  events.BUY_ITEM,
  ({ payload }) => ({
    itemId: payload.item.itemId,
    contractAddress: payload.item.contractAddress,
    rarity: payload.item.rarity,
    network: payload.item.network,
    chainId: payload.item.chainId,
    price: Number(ethers.utils.formatEther(payload.item.price)),
    data: payload.item.data
  })
)

track<BuyItemWithCardSuccessAction>(
  BUY_ITEM_WITH_CARD_SUCCESS,
  events.BUY_ITEM_WITH_CARD,
  ({ payload }) => ({
    itemId: payload.item.itemId,
    contractAddress: payload.item.contractAddress,
    rarity: payload.item.rarity,
    network: payload.item.network,
    chainId: payload.item.chainId,
    price: payload.purchase.nft.cryptoAmount,
    data: payload.item.data,
    purchase: payload.purchase
  })
)

track<SetIsTryingOnAction>(
  SET_IS_TRYING_ON,
  events.TOGGLE_PREVIEW_MODE,
  ({ payload }) => ({
    mode: payload.value ? 'avatar' : 'wearable'
  })
)

track<UpsertRentalSuccessAction>(
  UPSERT_RENTAL_SUCCESS,
  events.UPSERT_LAND_RENTAL,
  ({ payload: { nft, operationType, rental } }) => ({
    nftId: nft.id,
    assetType: isParcel(nft) ? NFTCategory.PARCEL : NFTCategory.ESTATE,
    rentalId: rental.id,
    pricePerDay: rental.periods[0].pricePerDay, // we're accepting just one price per day for all periods
    operation: operationType === UpsertRentalOptType.EDIT ? 'edit' : 'create',
    periods: rental.periods.map(period => period.maxDays).join(','), // maxDays is going to tell the duration for now
    experiesAt: rental.expiration
  })
)

track<ClaimAssetSuccessAction>(
  CLAIM_ASSET_SUCCESS,
  events.CLAIM_LAND_RENTAL,
  ({ payload: { nft, rental } }) => ({
    nftId: nft.id,
    rentalId: rental.id
  })
)

track<AcceptRentalListingSuccessAction>(
  ACCEPT_RENTAL_LISTING_SUCCESS,
  events.RENT_LAND,
  ({ payload: { periodIndexChosen, rental, nft } }) => ({
    nftId: rental.nftId,
    assetType: isParcel(nft) ? NFTCategory.PARCEL : NFTCategory.ESTATE,
    rentalId: rental.id,
    pricePerDay: rental.periods[periodIndexChosen].pricePerDay,
    duration: rental.periods[periodIndexChosen].maxDays
  })
)

track<SetPurchaseAction>(
  SET_PURCHASE,
  action =>
    action.payload.purchase.status === PurchaseStatus.CANCELLED
      ? events.PURCHASED_CANCELLED
      : action.payload.purchase.status === PurchaseStatus.COMPLETE
      ? events.PURCHASED_COMPLETE
      : action.payload.purchase.status === PurchaseStatus.REFUNDED
      ? events.PURCHASED_REFUNDED
      : action.payload.purchase.status === PurchaseStatus.FAILED
      ? events.PURCHASED_FAILED
      : events.PURCHASED_STARTED,
  action => action.payload.purchase
)

track<PickItemSuccessAction>(
  PICK_ITEM_SUCCESS,
  events.PICK_ITEM,
  ({ payload: { item, listId } }) => ({
    item,
    listId
  })
)

track<PickItemFailureAction>(
  PICK_ITEM_FAILURE,
  events.PICK_ITEM,
  ({ payload: { item, listId, error } }) => ({
    item,
    listId,
    error
  })
)

track<UnpickItemSuccessAction>(
  UNPICK_ITEM_SUCCESS,
  events.UNPICK_ITEM,
  ({ payload: { item, listId } }) => ({
    item,
    listId
  })
)

track<UnpickItemFailureAction>(
  UNPICK_ITEM_FAILURE,
  events.UNPICK_ITEM,
  ({ payload: { item, listId, error } }) => ({
    item,
    listId,
    error
  })
)

track<CreateListSuccessAction>(
  CREATE_LIST_SUCCESS,
  events.CREATE_LIST,
  ({ payload: { list } }) => ({
    list
  })
)

track<CreateListFailureAction>(
  CREATE_LIST_FAILURE,
  events.CREATE_LIST,
  ({ payload: { error } }) => ({
    error
  })
)

track<UpdateListSuccessAction>(
  UPDATE_LIST_SUCCESS,
  events.UPDATE_LIST,
  ({ payload: { list } }) => ({
    list
  })
)

track<UpdateListFailureAction>(
  UPDATE_LIST_FAILURE,
  events.UPDATE_LIST,
  ({ payload: { id, error } }) => ({
    id,
    error
  })
)

track<DeleteListSuccessAction>(
  DELETE_LIST_SUCCESS,
  events.DELETE_LIST,
  ({ payload: { list } }) => ({
    list
  })
)

track<DeleteListFailureAction>(
  DELETE_LIST_FAILURE,
  events.DELETE_LIST,
  ({ payload: { list, error } }) => ({
    list,
    error
  })
)

track<FetchCreatorsAccountSuccessAction>(
  FETCH_CREATORS_ACCOUNT_SUCCESS,
  events.SEARCH_RESULT,
  ({ payload: { creatorAccounts, search, searchUUID } }) => ({
    tab: 'creators',
    searchTerm: search,
    searchUUID,
    creators: creatorAccounts.map(creator => creator.address)
  })
)

1	import { PayloadAction } from 'typesafe-actions'
2	import { ethers } from 'ethers'
3	import {
4	EventName,
5	GetPayload
6	} from 'decentraland-dapps/dist/modules/analytics/types'
7	import {
8	FETCH_TRANSACTION_FAILURE,
9	FIX_REVERTED_TRANSACTION,
10	REPLACE_TRANSACTION_SUCCESS,
11	FetchTransactionFailureAction,
12	FixRevertedTransactionAction,
13	ReplaceTransactionSuccessAction
14	} from 'decentraland-dapps/dist/modules/transaction/actions'
15	import {
16	GrantTokenSuccessAction,
17	GRANT_TOKEN_SUCCESS,
18	RevokeTokenSuccessAction,
19	REVOKE_TOKEN_SUCCESS
20	} from 'decentraland-dapps/dist/modules/authorization/actions'
21	import { TransactionStatus } from 'decentraland-dapps/dist/modules/transaction/types'
22	import { add } from 'decentraland-dapps/dist/modules/analytics/utils'
23	import { capitalize } from '../../lib/text'
24	import {
25	CREATE_ORDER_SUCCESS,
26	CANCEL_ORDER_SUCCESS,
27	EXECUTE_ORDER_TRANSACTION_SUBMITTED,
28	CreateOrderSuccessAction,
29	CancelOrderSuccessAction,
30	ExecuteOrderTransactionSubmittedAction,
31	ExecuteOrderWithCardSuccessAction,
32	EXECUTE_ORDER_WITH_CARD_SUCCESS
33	} from '../order/actions'
34	import {
35	TRANSFER_NFT_TRANSACTION_SUBMITTED,
36	TransferNFTSuccessAction,
37	FETCH_NFTS_SUCCESS,
38	FetchNFTsSuccessAction
39	} from '../nft/actions'
40	import {
41	PLACE_BID_SUCCESS,
42	ACCEPT_BID_TRANSACTION_SUBMITTED,
43	CANCEL_BID_SUCCESS,
44	ARCHIVE_BID,
45	UNARCHIVE_BID,
46	PlaceBidSuccessAction,
47	CancelBidSuccessAction,
48	ArchiveBidAction,
49	UnarchiveBidAction,
50	AcceptBidTransactionSubmittedAction
51	} from '../bid/actions'
52	import {
53	BuyItemSuccessAction,
54	BuyItemWithCardSuccessAction,
55	BUY_ITEM_SUCCESS,
56	BUY_ITEM_WITH_CARD_SUCCESS,
57	FetchItemsSuccessAction,
58	FETCH_ITEMS_SUCCESS
59	} from '../item/actions'
60	import { SetIsTryingOnAction, SET_IS_TRYING_ON } from '../ui/preview/actions'
61	import { isParcel } from '../nft/utils'
62	import {
63	AcceptRentalListingSuccessAction,
64	ACCEPT_RENTAL_LISTING_SUCCESS,
65	ClaimAssetSuccessAction,
66	CLAIM_ASSET_SUCCESS,
67	UpsertRentalSuccessAction,
68	UPSERT_RENTAL_SUCCESS
69	} from '../rental/actions'
70	import { UpsertRentalOptType } from '../rental/types'
71	import { NFTCategory } from '@dcl/schemas'
72	import {
73	SetPurchaseAction,
74	SET_PURCHASE
75	} from 'decentraland-dapps/dist/modules/gateway/actions'
76	import { PurchaseStatus } from 'decentraland-dapps/dist/modules/gateway/types'
77	import * as events from '../../utils/events'
78	import {
79	CREATE_LIST_FAILURE,
80	CREATE_LIST_SUCCESS,
81	CreateListFailureAction,
82	CreateListSuccessAction,
83	DELETE_LIST_FAILURE,
84	DELETE_LIST_SUCCESS,
85	DeleteListFailureAction,
86	DeleteListSuccessAction,
87	PICK_ITEM_FAILURE,
88	PICK_ITEM_SUCCESS,
89	PickItemFailureAction,
90	PickItemSuccessAction,
91	UNPICK_ITEM_FAILURE,
92	UNPICK_ITEM_SUCCESS,
93	UPDATE_LIST_FAILURE,
94	UPDATE_LIST_SUCCESS,
95	UnpickItemFailureAction,
96	UnpickItemSuccessAction,
97	UpdateListFailureAction,
98	UpdateListSuccessAction
99	} from '../favorites/actions'
100	import { getCategoryInfo } from '../../utils/category'
101	import {
102	FETCH_CREATORS_ACCOUNT_SUCCESS,
103	FetchCreatorsAccountSuccessAction
104	} from '../account/actions'
105
106	function track<T extends PayloadAction<string, any>>(
107	actionType: string,
108	eventName: string \| ((action: T) => string),
109	getPayload = (action: T) => action.payload	×
110	) {
111	add(actionType, eventName as EventName, getPayload as GetPayload)	×
112	}
113
114	function withCategory(eventName: string, item: { category: string }) {
115	const category = capitalize(item.category)	×
116	return `${eventName} ${category}`	×
117	}
118
119	track<ExecuteOrderTransactionSubmittedAction>(	×
120	EXECUTE_ORDER_TRANSACTION_SUBMITTED,
121	({ payload }) => withCategory(events.BUY, payload.nft),	×
122	({ payload }) => ({	×
123	category: payload.nft.category,
124	nft: payload.nft.id,
125	price: payload.order.price,
126	seller: payload.order.owner,
127	buyer: payload.order.buyer,
128	...getCategoryInfo(payload.nft)
129	})
130	)
131
132	track<ExecuteOrderWithCardSuccessAction>(	×
133	EXECUTE_ORDER_WITH_CARD_SUCCESS,
134	({ payload }) => withCategory(events.BUY_WITH_CARD, payload.nft),	×
135	({ payload }) => ({	×
136	category: payload.nft.category,
137	nft: payload.nft.id,
138	price: payload.purchase.nft.cryptoAmount,
139	seller: payload.nft.owner,
140	buyer: payload.purchase.address
141	})
142	)
143
144	track<CreateOrderSuccessAction>(	×
145	CREATE_ORDER_SUCCESS,
146	({ payload }) => withCategory(events.PUBLISH, payload.nft),	×
147	({ payload }) => ({	×
148	category: payload.nft.category,
149	tokenId: payload.nft.tokenId,
150	price: payload.price
151	})
152	)
153
154	track<CancelOrderSuccessAction>(	×
155	CANCEL_ORDER_SUCCESS,
156	({ payload }) => withCategory(events.CANCEL_SALE, payload.nft),	×
157	({ payload }) => ({	×
158	category: payload.nft.category,
159	tokenId: payload.nft.tokenId,
160	price: payload.order.price
161	})
162	)
163
164	track<TransferNFTSuccessAction>(	×
165	TRANSFER_NFT_TRANSACTION_SUBMITTED,
166	({ payload }) => withCategory(events.TRANSFER_NFT, payload.nft),	×
167	({ payload }) => ({	×
168	category: payload.nft.category,
169	tokenId: payload.nft.tokenId,
170	to: payload.address
171	})
172	)
173
174	track<FetchTransactionFailureAction>(FETCH_TRANSACTION_FAILURE, ({ payload }) =>	×
175	payload.status === TransactionStatus.REVERTED	×
176	? events.TRANSACTION_FAILED
177	: events.TRANSACTION_DROPPED
178	)
179
180	track<FixRevertedTransactionAction>(	×
181	FIX_REVERTED_TRANSACTION,
182	events.TRANSACTION_FIXED
183	)
184
185	track<ReplaceTransactionSuccessAction>(	×
186	REPLACE_TRANSACTION_SUCCESS,
187	events.TRANSACTION_REPLACED
188	)
189
190	track<GrantTokenSuccessAction>(GRANT_TOKEN_SUCCESS, () => events.AUTHORIZE)	×
191
192	track<RevokeTokenSuccessAction>(REVOKE_TOKEN_SUCCESS, () => events.UNAUTHORIZE)	×
193
194	track<PlaceBidSuccessAction>(	×
195	PLACE_BID_SUCCESS,
196	({ payload }) => withCategory(events.BID, payload.nft),	×
197	({ payload }) => ({	×
198	category: payload.nft.category,
199	tokenId: payload.nft.tokenId,
200	price: payload.price,
201	bidder: payload.bidder
202	})
203	)
204
205	track<AcceptBidTransactionSubmittedAction>(	×
206	ACCEPT_BID_TRANSACTION_SUBMITTED,
207	events.ACCEPT_BID,
208	({ payload }) => ({	×
209	tokenId: payload.bid.tokenId,
210	bidId: payload.bid.id,
211	bidder: payload.bid.bidder,
212	seller: payload.bid.seller
213	})
214	)
215
216	track<CancelBidSuccessAction>(	×
217	CANCEL_BID_SUCCESS,
218	events.CANCEL_BID,
219	({ payload }) => ({	×
220	tokenId: payload.bid.tokenId,
221	bidId: payload.bid.id,
222	bidder: payload.bid.bidder
223	})
224	)
225
226	track<ArchiveBidAction>(ARCHIVE_BID, events.ARCHIVE_BID, ({ payload }) => ({	×
227	tokenId: payload.bid.tokenId,
228	bidId: payload.bid.id,
229	price: payload.bid.price
230	}))
231
232	track<UnarchiveBidAction>(	×
233	UNARCHIVE_BID,
234	events.UNARCHIVE_BID,
235	({ payload }) => ({	×
236	tokenId: payload.bid.tokenId,
237	bidId: payload.bid.id,
238	price: payload.bid.price
239	})
240	)
241
242	track<FetchNFTsSuccessAction>(	×
243	FETCH_NFTS_SUCCESS,
244	events.FETCH_NFTS,
245	({ payload }) => ({	×
246	...payload.options.params,
247	view: payload.options.view,
248	vendor: payload.options.vendor,
249	count: payload.count
250	})
251	)
252
253	track<FetchItemsSuccessAction>(	×
254	FETCH_ITEMS_SUCCESS,
255	events.FETCH_ITEMS,
256	({ payload }) => ({	×
257	options: payload.options,
258	total: payload.total
259	})
260	)
261
262	track<BuyItemSuccessAction>(	×
263	BUY_ITEM_SUCCESS,
264	events.BUY_ITEM,
265	({ payload }) => ({	×
266	itemId: payload.item.itemId,
267	contractAddress: payload.item.contractAddress,
268	rarity: payload.item.rarity,
269	network: payload.item.network,
270	chainId: payload.item.chainId,
271	price: Number(ethers.utils.formatEther(payload.item.price)),
272	data: payload.item.data
273	})
274	)
275
276	track<BuyItemWithCardSuccessAction>(	×
277	BUY_ITEM_WITH_CARD_SUCCESS,
278	events.BUY_ITEM_WITH_CARD,
279	({ payload }) => ({	×
280	itemId: payload.item.itemId,
281	contractAddress: payload.item.contractAddress,
282	rarity: payload.item.rarity,
283	network: payload.item.network,
284	chainId: payload.item.chainId,
285	price: payload.purchase.nft.cryptoAmount,
286	data: payload.item.data,
287	purchase: payload.purchase
288	})
289	)
290
291	track<SetIsTryingOnAction>(	×
292	SET_IS_TRYING_ON,
293	events.TOGGLE_PREVIEW_MODE,
294	({ payload }) => ({	×
295	mode: payload.value ? 'avatar' : 'wearable'	×
296	})
297	)
298
299	track<UpsertRentalSuccessAction>(	×
300	UPSERT_RENTAL_SUCCESS,
301	events.UPSERT_LAND_RENTAL,
302	({ payload: { nft, operationType, rental } }) => ({	×
303	nftId: nft.id,
304	assetType: isParcel(nft) ? NFTCategory.PARCEL : NFTCategory.ESTATE,	×
305	rentalId: rental.id,
306	pricePerDay: rental.periods[0].pricePerDay, // we're accepting just one price per day for all periods
307	operation: operationType === UpsertRentalOptType.EDIT ? 'edit' : 'create',	×
308	periods: rental.periods.map(period => period.maxDays).join(','), // maxDays is going to tell the duration for now	×
309	experiesAt: rental.expiration
310	})
311	)
312
313	track<ClaimAssetSuccessAction>(	×
314	CLAIM_ASSET_SUCCESS,
315	events.CLAIM_LAND_RENTAL,
316	({ payload: { nft, rental } }) => ({	×
317	nftId: nft.id,
318	rentalId: rental.id
319	})
320	)
321
322	track<AcceptRentalListingSuccessAction>(	×
323	ACCEPT_RENTAL_LISTING_SUCCESS,
324	events.RENT_LAND,
325	({ payload: { periodIndexChosen, rental, nft } }) => ({	×
326	nftId: rental.nftId,
327	assetType: isParcel(nft) ? NFTCategory.PARCEL : NFTCategory.ESTATE,	×
328	rentalId: rental.id,
329	pricePerDay: rental.periods[periodIndexChosen].pricePerDay,
330	duration: rental.periods[periodIndexChosen].maxDays
331	})
332	)
333
334	track<SetPurchaseAction>(	×
335	SET_PURCHASE,
336	action =>
337	action.payload.purchase.status === PurchaseStatus.CANCELLED	×
338	? events.PURCHASED_CANCELLED
339	: action.payload.purchase.status === PurchaseStatus.COMPLETE	×
340	? events.PURCHASED_COMPLETE
341	: action.payload.purchase.status === PurchaseStatus.REFUNDED	×
342	? events.PURCHASED_REFUNDED
343	: action.payload.purchase.status === PurchaseStatus.FAILED	×
344	? events.PURCHASED_FAILED
345	: events.PURCHASED_STARTED,
346	action => action.payload.purchase	×
347	)
348
349	track<PickItemSuccessAction>(	×
350	PICK_ITEM_SUCCESS,
351	events.PICK_ITEM,
352	({ payload: { item, listId } }) => ({	×
353	item,
354	listId
355	})
356	)
357
358	track<PickItemFailureAction>(	×
359	PICK_ITEM_FAILURE,
360	events.PICK_ITEM,
361	({ payload: { item, listId, error } }) => ({	×
362	item,
363	listId,
364	error
365	})
366	)
367
368	track<UnpickItemSuccessAction>(	×
369	UNPICK_ITEM_SUCCESS,
370	events.UNPICK_ITEM,
371	({ payload: { item, listId } }) => ({	×
372	item,
373	listId
374	})
375	)
376
377	track<UnpickItemFailureAction>(	×
378	UNPICK_ITEM_FAILURE,
379	events.UNPICK_ITEM,
380	({ payload: { item, listId, error } }) => ({	×
381	item,
382	listId,
383	error
384	})
385	)
386
387	track<CreateListSuccessAction>(	×
388	CREATE_LIST_SUCCESS,
389	events.CREATE_LIST,
390	({ payload: { list } }) => ({	×
391	list
392	})
393	)
394
395	track<CreateListFailureAction>(	×
396	CREATE_LIST_FAILURE,
397	events.CREATE_LIST,
398	({ payload: { error } }) => ({	×
399	error
400	})
401	)
402
403	track<UpdateListSuccessAction>(	×
404	UPDATE_LIST_SUCCESS,
405	events.UPDATE_LIST,
406	({ payload: { list } }) => ({	×
407	list
408	})
409	)
410
411	track<UpdateListFailureAction>(	×
412	UPDATE_LIST_FAILURE,
413	events.UPDATE_LIST,
414	({ payload: { id, error } }) => ({	×
415	id,
416	error
417	})
418	)
419
420	track<DeleteListSuccessAction>(	×
421	DELETE_LIST_SUCCESS,
422	events.DELETE_LIST,
423	({ payload: { list } }) => ({	×
424	list
425	})
426	)
427
428	track<DeleteListFailureAction>(	×
429	DELETE_LIST_FAILURE,
430	events.DELETE_LIST,
431	({ payload: { list, error } }) => ({	×
432	list,
433	error
434	})
435	)
436
437	track<FetchCreatorsAccountSuccessAction>(	×
438	FETCH_CREATORS_ACCOUNT_SUCCESS,
439	events.SEARCH_RESULT,
440	({ payload: { creatorAccounts, search, searchUUID } }) => ({	×
441	tab: 'creators',
442	searchTerm: search,
443	searchUUID,
444	creators: creatorAccounts.map(creator => creator.address)	×
445	})
446	)

decentraland / marketplace / 6468133945

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous