Merge branch 'trunk' into feat/15144-cash-receipt-style-updates

Author: jaclync

RELEASE-NOTES.txt

@@ -11,6 +11,7 @@
 - [*] Background image upload: Fix missing error notice in iPhones [https://github.com/woocommerce/woocommerce-ios/pull/15117]
 - [*] Background image upload: Show a notice when the user leaves product details while uploads are pending [https://github.com/woocommerce/woocommerce-ios/pull/15134]
 - [*] Filters applied in product selector no longer affect the main product list screen. [https://github.com/woocommerce/woocommerce-ios/pull/14764]
+- [**] Product Images: Update error handling [https://github.com/woocommerce/woocommerce-ios/pull/15105]
 
 21.7
 -----

WooCommerce/Classes/Analytics/WooAnalyticsStat.swift

@@ -822,6 +822,7 @@ enum WooAnalyticsStat: String {
     case productImageSettingsAddImagesSourceTapped = "product_image_settings_add_images_source_tapped"
     case productImageSettingsDeleteImageButtonTapped = "product_image_settings_delete_image_button_tapped"
     case productImageUploadFailed = "product_image_upload_failed"
+    case productImageUploadRetryButtonTapped = "product_image_upload_retry_button_tapped"
     case savingProductAfterBackgroundImageUploadSuccess = "saving_product_after_background_image_upload_success"
     case savingProductAfterBackgroundImageUploadFailed = "saving_product_after_background_image_upload_failed"
     case failureSavingProductAfterImageUploadNoticeShown = "failure_saving_product_after_image_upload_notice_shown"

WooCommerce/Classes/POS/Analytics/POSCollectOrderPaymentAnalytics.swift

@@ -1,17 +1,48 @@
+import protocol WooFoundation.Analytics
 import Yosemite
 
 final class POSCollectOrderPaymentAnalytics: CollectOrderPaymentAnalyticsTracking {
     var connectedReaderModel: String?
 
     private var customerInteractionStarted: Double = 0
+    private var orderCreated: Double = 0
+    private var cardReaderReady: Double = 0
+    private var cardReaderTapped: Double = 0
+    private var checkoutTapCount: Int = 0
+    private var hasTrackedProcessingPayment = false
+
+    private let analytics: Analytics
+
+    init(analytics: Analytics = ServiceLocator.analytics) {
+        self.analytics = analytics
+    }
 
     func preflightResultReceived(_ result: CardReaderPreflightResult?) { }
     func trackProcessingCompletion(intent: Yosemite.PaymentIntent) { }
 
     func trackSuccessfulPayment(capturedPaymentData: CardPresentCapturedPaymentData) {
-        let elapsedTime = calculateElapsedTimeInMilliseconds(start: customerInteractionStarted, end: Date().timeIntervalSince1970)
-        ServiceLocator.analytics.track(event:
-                .PointOfSale.cardPresentCollectPaymentSuccess(millisecondsSinceCustomerIteractionStated: elapsedTime))
+        // Property: milliseconds_since_customer_interaction_started
+        let elapsedTimeSinceCustomerInteraction = calculateElapsedTimeInMilliseconds(since: customerInteractionStarted)
+
+        // Property: milliseconds_since_order_creation_success
+        let elapsedTimeSinceOrderCreation = calculateElapsedTimeInMilliseconds(since: orderCreated)
+
+        // Property: milliseconds_since_reader_ready_to_collect_payment
+        let elapsedTimeSinceCardReaderReady = calculateElapsedTimeInMilliseconds(since: cardReaderReady)
+
+        // Property: milliseconds_since_card_tapped
+        let elapsedTimeSinceCardTapped = calculateElapsedTimeInMilliseconds(since: cardReaderTapped)
+
+        analytics.track(event: .PointOfSale.cardPresentCollectPaymentSuccess(
+            millisecondsSinceCustomerIteractionStarted: elapsedTimeSinceCustomerInteraction,
+            millisecondsSinceOrderCreationSuccess: elapsedTimeSinceOrderCreation,
+            millisecondsSinceReaderReadyToCollect: elapsedTimeSinceCardReaderReady,
+            millisecondsSinceCardTapped: elapsedTimeSinceCardTapped,
+            checkoutTapCount: checkoutTapCount
+        ))
+
+        resetCheckoutTapCountTracker()
+        resetProcessingPaymentTracking()
     }
 
     func trackPaymentFailure(with error: any Error) { }
@@ -23,15 +54,68 @@ final class POSCollectOrderPaymentAnalytics: CollectOrderPaymentAnalyticsTrackin
     func trackReceiptPrintFailed(error: any Error) { }
 
     func trackCustomerInteractionStarted() {
+        // Any action that is considered as user starting an iteraction resets any ongoing counter
+        resetAllCountersOnInteractionStarted()
         customerInteractionStarted = Date().timeIntervalSince1970
     }
 
-    private func calculateElapsedTimeInMilliseconds(start: Double, end: Double) -> Double {
-        floor((end - start) * 1000)
+    func trackOrderCreationSuccess() {
+        orderCreated = trackCurrentTime()
+    }
+
+    func trackCardReaderReady() {
+        cardReaderReady = trackCurrentTime()
+    }
+
+    // The Stripe SDK returns multiple `.processing` events, but we want to capture the first one in the stream only.
+    // This flag is reset as soon as the payment has been successful
+    func trackCardReaderTapped() {
+        if !hasTrackedProcessingPayment {
+            hasTrackedProcessingPayment = true
+            cardReaderTapped = trackCurrentTime()
+        }
+    }
+
+    func trackCheckoutTapped() {
+        checkoutTapCount += 1
+    }
+
+    func resetCheckoutTapCountTracker() {
+        checkoutTapCount = 0
+    }
+}
+
+// Helpers
+private extension POSCollectOrderPaymentAnalytics {
+    func trackCurrentTime() -> Double {
+        Date().timeIntervalSince1970
+    }
+
+    func calculateElapsedTimeInMilliseconds(since start: Double) -> Double {
+        let end = Date().timeIntervalSince1970
+        return floor((end - start) * 1000)
+    }
+
+    private func resetProcessingPaymentTracking() {
+        hasTrackedProcessingPayment = false
+    }
+
+    private func resetAllCountersOnInteractionStarted() {
+        orderCreated = 0
+        cardReaderReady = 0
+        cardReaderTapped = 0
+        resetCheckoutTapCountTracker()
+        resetProcessingPaymentTracking()
     }
 }
 
 // Protocol conformance. These events are not needed for IPP, only for POS.
+// https://github.com/woocommerce/woocommerce-ios/issues/15149
 extension CollectOrderPaymentAnalytics {
     func trackCustomerInteractionStarted() { }
+    func trackOrderCreationSuccess() { }
+    func trackCardReaderReady() { }
+    func trackCardReaderTapped() { }
+    func trackCheckoutTapped() { }
+    func resetCheckoutTapCountTracker() { }
 }

WooCommerce/Classes/POS/Analytics/WooAnalyticsEvent+PointOfSale.swift

@@ -13,6 +13,10 @@ extension WooAnalyticsEvent {
             static let itemType = "product_type"
             static let itemsInCart = "items_in_cart"
             static let millisecondsSinceCustomerInteractionStarted = "milliseconds_since_customer_interaction_started"
+            static let millisecondsSinceOrderCreationSuccess = "milliseconds_since_order_creation_success"
+            static let millisecondsSinceReaderReadyToCollect = "milliseconds_since_reader_ready_to_collect_payment"
+            static let millisecondsSinceCardTapped = "milliseconds_since_card_tapped"
+            static let checkoutTapCount = "checkout_tap_count"
         }
 
         static func paymentsOnboardingShown() -> WooAnalyticsEvent {
@@ -33,10 +37,18 @@ extension WooAnalyticsEvent {
                               properties: [Key.itemsInCart: itemsInCart])
         }
 
-        static func cardPresentCollectPaymentSuccess(millisecondsSinceCustomerIteractionStated: Double) -> WooAnalyticsEvent {
+        static func cardPresentCollectPaymentSuccess(millisecondsSinceCustomerIteractionStarted: Double,
+                                                     millisecondsSinceOrderCreationSuccess: Double,
+                                                     millisecondsSinceReaderReadyToCollect: Double,
+                                                     millisecondsSinceCardTapped: Double,
+                                                     checkoutTapCount: Int) -> WooAnalyticsEvent {
             WooAnalyticsEvent(statName: .collectPaymentSuccess, properties: [
-                Key.millisecondsSinceCustomerInteractionStarted: "\(millisecondsSinceCustomerIteractionStated)"]
-            )
+                Key.millisecondsSinceCustomerInteractionStarted: "\(millisecondsSinceCustomerIteractionStarted)",
+                Key.millisecondsSinceOrderCreationSuccess: "\(millisecondsSinceOrderCreationSuccess)",
+                Key.millisecondsSinceReaderReadyToCollect: "\(millisecondsSinceReaderReadyToCollect)",
+                Key.millisecondsSinceCardTapped: "\(millisecondsSinceCardTapped)",
+                Key.checkoutTapCount: "\(checkoutTapCount)"
+            ])
         }
     }
 }

WooCommerce/Classes/POS/Controllers/PointOfSaleOrderController.swift

@@ -13,10 +13,21 @@ import class WooFoundation.CurrencySettings
 import enum WooFoundation.CurrencyCode
 import protocol WooFoundation.Analytics
 
+enum SyncOrderState {
+    case newOrder
+    case orderUpdated
+    case orderNotChanged
+}
+
+enum SyncOrderStateError: Error {
+    case syncFailure
+}
+
 protocol PointOfSaleOrderControllerProtocol {
     var orderState: PointOfSaleInternalOrderState { get }
 
-    func syncOrder(for cartProducts: [CartItem], retryHandler: @escaping () async -> Void) async
+    @discardableResult
+    func syncOrder(for cartProducts: [CartItem], retryHandler: @escaping () async -> Void) async -> Result<SyncOrderState, Error>
     func sendReceipt(recipientEmail: String) async throws
     func clearOrder()
     func collectCashPayment() async throws
@@ -51,16 +62,15 @@ protocol PointOfSaleOrderControllerProtocol {
     private(set) var orderState: PointOfSaleInternalOrderState = .idle
     private var order: Order? = nil
 
-    @MainActor
+    @MainActor @discardableResult
     func syncOrder(for cartItems: [CartItem],
-                   retryHandler: @escaping () async -> Void) async {
+                   retryHandler: @escaping () async -> Void) async -> Result<SyncOrderState, Error> {
         let posCartItems = cartItems.map {
             POSCartItem(item: $0.item, quantity: Decimal($0.quantity))
         }
 
-        guard !orderState.isSyncing,
-              !posCartItems.matches(order: order) else {
-            return
+        guard !orderState.isSyncing, !posCartItems.matches(order: order) else {
+            return .success(.orderNotChanged)
         }
 
         orderState = .syncing
@@ -74,6 +84,9 @@ protocol PointOfSaleOrderControllerProtocol {
             orderState = .loaded(totals(for: syncedOrder), syncedOrder)
             if isNewOrder {
                 analytics.track(.orderCreationSuccess)
+                return .success(.newOrder)
+            } else {
+                return .success(.orderUpdated)
             }
         } catch {
             if isNewOrder {
@@ -83,6 +96,7 @@ protocol PointOfSaleOrderControllerProtocol {
                     errorDescription: error.localizedDescription))
             }
             setOrderStateToError(error, retryHandler: retryHandler)
+            return .failure(SyncOrderStateError.syncFailure)
         }
     }
 

WooCommerce/Classes/POS/Models/PointOfSaleAggregateModel.swift

@@ -250,6 +250,8 @@ extension PointOfSaleAggregateModel {
 
     private func cashPaymentSuccess() {
         paymentState = .cash(.paymentSuccess)
+        // TODO: Move to trackSuccessfulCashPayment() on #15151
+        collectOrderPaymentAnalyticsTracker.resetCheckoutTapCountTracker()
     }
 
     @MainActor
@@ -365,6 +367,14 @@ private extension PointOfSaleAggregateModel {
                 let newPaymentState = PointOfSalePaymentState(from: paymentEvent,
                                                               using: presentationStyleDeterminerDependencies)
 
+                if case .card(.acceptingCard) = newPaymentState {
+                    collectOrderPaymentAnalyticsTracker.trackCardReaderReady()
+                }
+
+                if case .card(.processingPayment) = newPaymentState {
+                    collectOrderPaymentAnalyticsTracker.trackCardReaderTapped()
+                }
+
                 return newPaymentState
             }
             .sink(receiveValue: { [weak self] paymentState in
@@ -438,10 +448,14 @@ private extension PointOfSaleAggregateModel {
 extension PointOfSaleAggregateModel {
     @MainActor
     func checkOut() async {
+        collectOrderPaymentAnalyticsTracker.trackCheckoutTapped()
         orderStage = .finalizing
-        await orderController.syncOrder(for: cart, retryHandler: { [weak self] in
+        let syncOrderResult = await orderController.syncOrder(for: cart, retryHandler: { [weak self] in
             await self?.checkOut()
         })
+        if case .success(.newOrder) = syncOrderResult {
+            collectOrderPaymentAnalyticsTracker.trackOrderCreationSuccess()
+        }
         await startPaymentWhenCardReaderConnected()
     }
 }

WooCommerce/Classes/POS/Presentation/PointOfSaleDashboardView.swift

@@ -33,7 +33,6 @@ struct PointOfSaleDashboardView: View {
                 case .content:
                     contentView
                         .accessibilitySortPriority(2)
-                        .ignoresSafeArea(edges: .bottom)
                 }
             } else {
                 PointOfSaleUnsupportedWidthView()
@@ -45,6 +44,7 @@ struct PointOfSaleDashboardView: View {
                                    showSupport: $showSupport,
                                    showDocumentation: $showDocumentation)
             .offset(x: Constants.floatingControlHorizontalOffset, y: -Constants.floatingControlVerticalOffset)
+            .padding(.bottom, Constants.floatingControlBottomPadding)
             .trackSize(size: $floatingSize)
             .accessibilitySortPriority(1)
             .renderedIf(posModel.itemsViewState.containerState != .loading)
@@ -100,7 +100,6 @@ struct PointOfSaleDashboardView: View {
                     CartView()
                         .accessibilitySortPriority(1)
                         .frame(width: geometry.size.width * Constants.cartWidth)
-                        .ignoresSafeArea(edges: .bottom)
                 }
 
                 if posModel.orderStage == .finalizing {
@@ -168,6 +167,7 @@ private extension PointOfSaleDashboardView {
         // For the moment we're just considering landscape for the POS mode
         // https://github.com/woocommerce/woocommerce-ios/issues/13251
         static let cartWidth: CGFloat = 0.35
+        static let floatingControlBottomPadding: CGFloat = 16
         static let floatingControlHorizontalOffset: CGFloat = 16
         static let floatingControlVerticalOffset: CGFloat = 0
         static let exitPOSSheetMaxWidth: CGFloat = 900.0

WooCommerce/Classes/POS/Presentation/TotalsView.swift

@@ -363,7 +363,7 @@ private extension TotalsView {
         static let pricesIdealWidth: CGFloat = 382
         static let verticalSpacing: CGFloat = 56
         static let buttonHorizontalPadding: CGFloat = 48
-        static let cashButtonBottomPadding: CGFloat = 24
+        static let cashButtonBottomPadding: CGFloat = 16
 
         static let totalsLineViewPadding: EdgeInsets = .init(top: 20, leading: 24, bottom: 20, trailing: 24)
         static let subtotalsVerticalSpacing: CGFloat = 8

WooCommerce/Classes/POS/Utils/PointOfSalePreviewOrderController.swift

@@ -12,8 +12,9 @@ class PointOfSalePreviewOrderController: PointOfSaleOrderControllerProtocol {
         OrderFactory.newOrder(currency: .USD)
     )
 
-    func syncOrder(for cartProducts: [CartItem],
-                   retryHandler: @escaping () async -> Void) async { }
+    func syncOrder(for cartProducts: [CartItem], retryHandler: @escaping () async -> Void) async -> Result<SyncOrderState, Error> {
+        return .success(.newOrder)
+    }
 
     func sendReceipt(recipientEmail: String) async throws { }