Create POSOrderMapper to set formatted and calculated totals on POSOrder

Author: staskus

Modules/Sources/Yosemite/PointOfSale/OrderList/POSOrder.swift

@@ -13,35 +13,49 @@ public struct POSOrder: Equatable, Hashable {
     public let datePaid: Date?
     public let status: OrderStatusEnum
     public let total: String
+    public let formattedTotal: String
+    public let formattedSubtotal: String
     public let customerEmail: String?
     public let paymentMethodID: String
     public let paymentMethodTitle: String
     public let lineItems: [POSOrderItem]
     public let refunds: [POSOrderRefund]
     public let currency: String
     public let discountTotal: String
+    public let formattedDiscountTotal: String?
     public let totalTax: String
+    public let formattedTotalTax: String
+    public let formattedPaymentTotal: String
+    public let formattedNetAmount: String?
 
     public init(id: Int64,
                 number: String,
                 dateCreated: Date,
                 datePaid: Date? = nil,
                 status: OrderStatusEnum,
                 total: String,
+                formattedTotal: String,
+                formattedSubtotal: String,
                 customerEmail: String? = nil,
                 paymentMethodID: String,
                 paymentMethodTitle: String,
                 lineItems: [POSOrderItem] = [],
                 refunds: [POSOrderRefund] = [],
                 currency: String,
                 discountTotal: String,
-                totalTax: String) {
+                totalTax: String,
+                formattedTotalTax: String,
+                formattedDiscountTotal: String?,
+                formattedPaymentTotal: String,
+                formattedNetAmount: String? = nil) {
         self.id = id
         self.number = number
         self.dateCreated = dateCreated
         self.datePaid = datePaid
         self.status = status
         self.total = total
+        self.formattedTotal = formattedTotal
+        self.formattedSubtotal = formattedSubtotal
         self.customerEmail = customerEmail
         self.paymentMethodID = paymentMethodID
         self.paymentMethodTitle = paymentMethodTitle
@@ -50,36 +64,9 @@ public struct POSOrder: Equatable, Hashable {
         self.currency = currency
         self.discountTotal = discountTotal
         self.totalTax = totalTax
-    }
-}
-
-// MARK: - Conversion from NetworkingCore.Order
-public extension POSOrder {
-    init(from order: NetworkingCore.Order) {
-        // Extract customer email from billing address
-        let customerEmail = order.billingAddress?.email
-
-        // Convert line items to POS format
-        let posLineItems = order.items.map { POSOrderItem(from: $0) }
-
-        // Convert refunds to POS format
-        let posRefunds = order.refunds.map { POSOrderRefund(from: $0) }
-
-        self.init(
-            id: order.orderID,
-            number: order.number,
-            dateCreated: order.dateCreated,
-            datePaid: order.datePaid,
-            status: order.status,
-            total: order.total,
-            customerEmail: customerEmail,
-            paymentMethodID: order.paymentMethodID,
-            paymentMethodTitle: order.paymentMethodTitle,
-            lineItems: posLineItems,
-            refunds: posRefunds,
-            currency: order.currency,
-            discountTotal: order.discountTotal,
-            totalTax: order.totalTax
-        )
+        self.formattedTotalTax = formattedTotalTax
+        self.formattedDiscountTotal = formattedDiscountTotal
+        self.formattedPaymentTotal = formattedPaymentTotal
+        self.formattedNetAmount = formattedNetAmount
     }
 }

Modules/Sources/Yosemite/PointOfSale/OrderList/POSOrderItem.swift

@@ -1,6 +1,4 @@
 import Foundation
-import struct NetworkingCore.OrderItem
-import struct NetworkingCore.OrderItemAttribute
 
 public struct POSOrderItem: Equatable, Hashable {
     public let itemID: Int64
@@ -9,8 +7,10 @@ public struct POSOrderItem: Equatable, Hashable {
     public let variationID: Int64
     public let quantity: Decimal
     public let price: NSDecimalNumber
+    public let formattedPrice: String
     public let subtotal: String
     public let total: String
+    public let formattedTotal: String
     public let attributes: [OrderItemAttribute]
 
     public init(itemID: Int64,
@@ -19,34 +19,21 @@ public struct POSOrderItem: Equatable, Hashable {
                 variationID: Int64,
                 quantity: Decimal,
                 price: NSDecimalNumber,
+                formattedPrice: String,
                 subtotal: String,
                 total: String,
+                formattedTotal: String,
                 attributes: [OrderItemAttribute]) {
         self.itemID = itemID
         self.name = name
         self.productID = productID
         self.variationID = variationID
         self.quantity = quantity
         self.price = price
+        self.formattedPrice = formattedPrice
         self.subtotal = subtotal
         self.total = total
+        self.formattedTotal = formattedTotal
         self.attributes = attributes
     }
 }
-
-// MARK: - Conversion from NetworkingCore.OrderItem
-public extension POSOrderItem {
-    init(from orderItem: OrderItem) {
-        self.init(
-            itemID: orderItem.itemID,
-            name: orderItem.name,
-            productID: orderItem.productID,
-            variationID: orderItem.variationID,
-            quantity: orderItem.quantity,
-            price: orderItem.price,
-            subtotal: orderItem.subtotal,
-            total: orderItem.total,
-            attributes: orderItem.attributes
-        )
-    }
-}

Modules/Sources/Yosemite/PointOfSale/OrderList/POSOrderMapper.swift

@@ -0,0 +1,77 @@
+import Foundation
+import class WooFoundationCore.CurrencyFormatter
+import struct NetworkingCore.Order
+import struct NetworkingCore.OrderItem
+import struct NetworkingCore.OrderItemAttribute
+import struct NetworkingCore.OrderRefundCondensed
+
+struct POSOrderMapper {
+    private let currencyFormatter: CurrencyFormatter
+
+    init(currencyFormatter: CurrencyFormatter) {
+        self.currencyFormatter = currencyFormatter
+    }
+
+    func map(order: NetworkingCore.Order) -> POSOrder {
+        let customerEmail = order.billingAddress?.email
+
+        let posLineItems = order.items.map { map(orderItem: $0, currency: order.currency) }
+
+        let posRefunds = order.refunds.map { map(orderRefund: $0, currency: order.currency) }
+
+        let formattedDiscountTotal: String? = {
+            guard let discountTotalValue = Double(order.discountTotal), discountTotalValue > 0 else {
+                return nil
+            }
+            return currencyFormatter.formatAmount(order.discountTotal, with: order.currency, isNegative: true) ?? ""
+        }()
+
+        return POSOrder(
+            id: order.orderID,
+            number: order.number,
+            dateCreated: order.dateCreated,
+            datePaid: order.datePaid,
+            status: order.status,
+            total: order.total,
+            formattedTotal: currencyFormatter.formatAmount(order.total, with: order.currency) ?? "",
+            formattedSubtotal: order.subtotalValue(currencyFormatter: currencyFormatter),
+            customerEmail: customerEmail,
+            paymentMethodID: order.paymentMethodID,
+            paymentMethodTitle: order.paymentMethodTitle,
+            lineItems: posLineItems,
+            refunds: posRefunds,
+            currency: order.currency,
+            discountTotal: order.discountTotal,
+            totalTax: order.totalTax,
+            formattedTotalTax: currencyFormatter.formatAmount(order.totalTax, with: order.currency) ?? "",
+            formattedDiscountTotal: formattedDiscountTotal,
+            formattedPaymentTotal: order.paymentTotal(currencyFormatter: currencyFormatter),
+            formattedNetAmount: order.netAmount(currencyFormatter: currencyFormatter)
+        )
+    }
+
+    private func map(orderItem: NetworkingCore.OrderItem, currency: String) -> POSOrderItem {
+        return POSOrderItem(
+            itemID: orderItem.itemID,
+            name: orderItem.name,
+            productID: orderItem.productID,
+            variationID: orderItem.variationID,
+            quantity: orderItem.quantity,
+            price: orderItem.price,
+            formattedPrice: currencyFormatter.formatAmount(orderItem.price, with: currency) ?? "",
+            subtotal: orderItem.subtotal,
+            total: orderItem.total,
+            formattedTotal: currencyFormatter.formatAmount(orderItem.total, with: currency) ?? "",
+            attributes: orderItem.attributes
+        )
+    }
+
+    private func map(orderRefund: NetworkingCore.OrderRefundCondensed, currency: String) -> POSOrderRefund {
+        return POSOrderRefund(
+            refundID: orderRefund.refundID,
+            total: orderRefund.total,
+            formattedTotal: currencyFormatter.formatAmount(orderRefund.total, with: currency) ?? "",
+            reason: orderRefund.reason
+        )
+    }
+}

Modules/Sources/Yosemite/PointOfSale/OrderList/POSOrderRefund.swift

@@ -1,27 +1,20 @@
 import Foundation
 import struct NetworkingCore.OrderRefundCondensed
+import class WooFoundationCore.CurrencyFormatter
 
 public struct POSOrderRefund: Equatable, Hashable {
     public let refundID: Int64
     public let total: String
+    public let formattedTotal: String
     public let reason: String?
 
     public init(refundID: Int64,
                 total: String,
+                formattedTotal: String,
                 reason: String? = nil) {
         self.refundID = refundID
         self.total = total
+        self.formattedTotal = formattedTotal
         self.reason = reason
     }
 }
-
-// MARK: - Conversion from NetworkingCore.OrderRefundCondensed
-public extension POSOrderRefund {
-    init(from refund: OrderRefundCondensed) {
-        self.init(
-            refundID: refund.refundID,
-            total: refund.total,
-            reason: refund.reason
-        )
-    }
-}

Modules/Sources/Yosemite/PointOfSale/OrderList/PointOfSaleOrderListFetchStrategyFactory.swift

@@ -1,6 +1,7 @@
 import Foundation
 import class Networking.AlamofireNetwork
 import class Networking.OrdersRemote
+import class WooFoundationCore.CurrencyFormatter
 
 public protocol PointOfSaleOrderListFetchStrategyFactoryProtocol {
     func defaultStrategy() -> PointOfSaleOrderListFetchStrategy
@@ -9,16 +10,24 @@ public protocol PointOfSaleOrderListFetchStrategyFactoryProtocol {
 public final class PointOfSaleOrderListFetchStrategyFactory: PointOfSaleOrderListFetchStrategyFactoryProtocol {
     private let siteID: Int64
     private let ordersRemote: OrdersRemote
+    private let currencyFormatter: CurrencyFormatter
 
     public init(siteID: Int64,
-                credentials: Credentials?) {
+                credentials: Credentials?,
+                currencyFormatter: CurrencyFormatter) {
         self.siteID = siteID
         let network = AlamofireNetwork(credentials: credentials)
         self.ordersRemote = OrdersRemote(network: network)
+        self.currencyFormatter = currencyFormatter
     }
 
     public func defaultStrategy() -> PointOfSaleOrderListFetchStrategy {
-        PointOfSaleDefaultOrderListFetchStrategy(orderListService: PointOfSaleOrderListService(siteID: siteID,
-                                                                                               ordersRemote: ordersRemote))
+        PointOfSaleDefaultOrderListFetchStrategy(
+            orderListService: PointOfSaleOrderListService(
+                siteID: siteID,
+                ordersRemote: ordersRemote,
+                currencyFormatter: currencyFormatter
+            )
+        )
     }
 }

Modules/Sources/Yosemite/PointOfSale/OrderList/PointOfSaleOrderListService.swift

@@ -3,14 +3,21 @@ import enum Alamofire.AFError
 import struct NetworkingCore.PagedItems
 import struct NetworkingCore.Order
 import protocol NetworkingCore.POSOrdersRemoteProtocol
+import class WooFoundationCore.CurrencyFormatter
 
 public final class PointOfSaleOrderListService: PointOfSaleOrderListServiceProtocol {
     private let ordersRemote: POSOrdersRemoteProtocol
     private let siteID: Int64
+    private let mapper: POSOrderMapper
 
-    public init(siteID: Int64, ordersRemote: POSOrdersRemoteProtocol) {
+    public init(
+        siteID: Int64,
+        ordersRemote: POSOrdersRemoteProtocol,
+        currencyFormatter: CurrencyFormatter
+    ) {
         self.siteID = siteID
         self.ordersRemote = ordersRemote
+        self.mapper = POSOrderMapper(currencyFormatter: currencyFormatter)
     }
 
     public func providePointOfSaleOrders(pageNumber: Int = 1) async throws -> PagedItems<POSOrder> {
@@ -26,7 +33,7 @@ public final class PointOfSaleOrderListService: PointOfSaleOrderListServiceProto
             }
 
             // Convert Order objects to POSOrder objects
-            let posOrders = pagedOrders.items.map { POSOrder(from: $0) }
+            let posOrders = pagedOrders.items.map { mapper.map(order: $0) }
 
             return .init(items: posOrders,
                         hasMorePages: pagedOrders.hasMorePages,

WooCommerce/Classes/POS/Controllers/PointOfSaleOrderListController.swift

@@ -10,7 +10,7 @@ import struct Yosemite.POSOrderRefund
 import class Yosemite.Store
 
 protocol PointOfSaleOrderListControllerProtocol {
-    var ordersViewState: OrderListState { get }
+    var ordersViewState: POSOrderListState { get }
     var selectedOrder: POSOrder? { get }
     func loadOrders() async
     func refreshOrders() async
@@ -19,14 +19,14 @@ protocol PointOfSaleOrderListControllerProtocol {
 }
 
 @Observable final class PointOfSaleOrderListController: PointOfSaleOrderListControllerProtocol {
-    var ordersViewState: OrderListState
+    var ordersViewState: POSOrderListState
     private let paginationTracker: AsyncPaginationTracker
     private var fetchStrategy: PointOfSaleOrderListFetchStrategy
     private var cachedOrders: [POSOrder] = []
     private(set) var selectedOrder: POSOrder?
 
     init(orderListFetchStrategyFactory: PointOfSaleOrderListFetchStrategyFactoryProtocol,
-         initialState: OrderListState = .loading([])) {
+         initialState: POSOrderListState = .loading([])) {
         self.ordersViewState = initialState
         self.paginationTracker = .init()
         self.fetchStrategy = orderListFetchStrategyFactory.defaultStrategy()
@@ -59,7 +59,7 @@ protocol PointOfSaleOrderListControllerProtocol {
         } catch {
             ordersViewState = .inlineError(currentOrders,
                                           error: .errorOnLoadingOrdersNextPage(error: error),
-                                          context: OrderListState.InlineErrorContext.pagination)
+                                          context: POSOrderListState.InlineErrorContext.pagination)
         }
     }
 
@@ -77,7 +77,7 @@ protocol PointOfSaleOrderListControllerProtocol {
             } else {
                 ordersViewState = .inlineError(orders,
                                               error: .errorOnLoadingOrders(error: error),
-                                              context: OrderListState.InlineErrorContext.refresh)
+                                              context: POSOrderListState.InlineErrorContext.refresh)
             }
         }
     }

WooCommerce/Classes/POS/TabBar/POSTabCoordinator.swift

@@ -5,6 +5,7 @@ import Yosemite
 import class WooFoundation.CurrencySettings
 import protocol Storage.StorageManagerType
 import protocol Storage.GRDBManagerProtocol
+import class WooFoundationCore.CurrencyFormatter
 
 /// View controller that provides the tab bar item for the Point of Sale tab.
 /// It is never visible on the screen, only used to provide the tab bar item as all POS UI is full-screen.
@@ -126,8 +127,11 @@ private extension POSTabCoordinator {
                     couponsSearchController: PointOfSaleCouponsController(itemProvider: posCouponProvider,
                                                                           fetchStrategyFactory: posCouponFetchStrategyFactory),
                     ordersController: PointOfSaleOrderListController(
-                        orderListFetchStrategyFactory: PointOfSaleOrderListFetchStrategyFactory(siteID: siteID,
-                                                                                        credentials: credentials)
+                        orderListFetchStrategyFactory: PointOfSaleOrderListFetchStrategyFactory(
+                            siteID: siteID,
+                            credentials: credentials,
+                            currencyFormatter: CurrencyFormatter(currencySettings: currencySettings)
+                        )
                     ),
 
                     onPointOfSaleModeActiveStateChange: { [weak self] isEnabled in