Merge pull request #1980 from OpenBazaar/1976-normalize-legacy-listings

(#1976) Normalize legacy listings via GET /ob/listings/...

Author: placer14

api/jsonapi.go

@@ -1496,6 +1496,11 @@ func (i *jsonAPIHandler) GETListing(w http.ResponseWriter, r *http.Request) {
 			log.Warningf("updating coupons for listing (%s): %s", rsl.GetSlug(), err.Error())
 		}
 
+		if err := rsl.Normalize(); err != nil {
+			ErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("normalizing listing: %s", err.Error()))
+			return
+		}
+
 		out, err := rsl.MarshalJSON()
 		if err != nil {
 			ErrorResponse(w, http.StatusInternalServerError, err.Error())
@@ -1537,7 +1542,14 @@ func (i *jsonAPIHandler) GETListing(w http.ResponseWriter, r *http.Request) {
 	}
 	sl.Hash = hash
 
-	out, err := repo.NewSignedListingFromProtobuf(sl).MarshalJSON()
+	rsl := repo.NewSignedListingFromProtobuf(sl)
+
+	if err := rsl.Normalize(); err != nil {
+		ErrorResponse(w, http.StatusInternalServerError, fmt.Sprintf("normalizing listing: %s", err.Error()))
+		return
+	}
+
+	out, err := rsl.MarshalJSON()
 	if err != nil {
 		ErrorResponse(w, http.StatusInternalServerError, err.Error())
 		return

core/order.go

@@ -61,6 +61,21 @@ func (n *OpenBazaarNode) GetOrder(orderID string) (*pb.OrderRespApi, error) {
 		}
 		isSale = true
 	}
+
+	for i, l := range contract.VendorListings {
+		repoListing, err := repo.NewListingFromProtobuf(l)
+		if err != nil {
+			log.Errorf("failed getting contract listing: %s", err.Error())
+			return nil, err
+		}
+		normalizedListing, err := repoListing.Normalize()
+		if err != nil {
+			log.Errorf("failed converting contract listing to v5 schema: %s", err.Error())
+			return nil, err
+		}
+		contract.VendorListings[i] = normalizedListing.GetProtobuf()
+	}
+
 	resp := new(pb.OrderRespApi)
 	resp.Contract = contract
 	resp.Funded = funded

repo/db/sales.go

@@ -315,9 +315,11 @@ func (s *SalesDB) GetByOrderId(orderId string) (*pb.RicardianContract, pb.OrderS
 		return nil, pb.OrderState(0), false, nil, false, nil, fmt.Errorf("validating payment coin: %s", err.Error())
 	}
 	var records []*wallet.TransactionRecord
-	err = json.Unmarshal(serializedTransactions, &records)
-	if err != nil {
-		log.Error(err)
+	if len(serializedTransactions) > 0 {
+		err = json.Unmarshal(serializedTransactions, &records)
+		if err != nil {
+			return nil, pb.OrderState(0), false, nil, false, nil, fmt.Errorf("unmarshal purchase transactions: %s", err.Error())
+		}
 	}
 	cc := def.CurrencyCode()
 	return rc, pb.OrderState(stateInt), funded, records, read, &cc, nil

repo/listing.go

@@ -138,14 +138,16 @@ func (*Listing) ProtoMessage()    {}
 
 // NewListingFromProtobuf - return Listing from pb.Listing
 func NewListingFromProtobuf(l *pb.Listing) (*Listing, error) {
-	if l.Metadata.Version == 0 {
-		l.Metadata.Version = ListingVersion
+	clonedListing := proto.Clone(l).(*pb.Listing)
+
+	if clonedListing.Metadata.Version == 0 {
+		clonedListing.Metadata.Version = ListingVersion
 	}
-	if l.Metadata.EscrowTimeoutHours == 0 {
-		l.Metadata.EscrowTimeoutHours = DefaultEscrowTimeout
+	if clonedListing.Metadata.EscrowTimeoutHours == 0 {
+		clonedListing.Metadata.EscrowTimeoutHours = DefaultEscrowTimeout
 	}
 	return &Listing{
-		listingProto: l,
+		listingProto: clonedListing,
 	}, nil
 }
 
@@ -376,6 +378,59 @@ func ExtractIDFromListing(data []byte) (*pb.ID, error) {
 	return vendorPlay, nil
 }
 
+// Normalize converts legacy schema listing data from other users on the network
+// to fit the latest schema for consumption via the API for local use. NOTE: Legacy
+// nodes do not understand the latest schema. As such, normalized listings must not
+// be used as part of the RicardianContract and must be serialized and used as they
+// were provided by the originating node.
+func (l *Listing) Normalize() (*Listing, error) {
+	if l == nil {
+		return nil, errors.New("nil listing cannot be normalized")
+	}
+
+	if l.GetVersion() == ListingVersion {
+		return l, nil
+	}
+
+	nl, err := NewListingFromProtobuf(l.listingProto)
+	if err != nil {
+		return nil, fmt.Errorf("creating listing clone: %s", err.Error())
+	}
+
+	nlp := nl.GetProtobuf()
+	nlp.Metadata.Version = ListingVersion
+
+	if p, err := l.GetPrice(); err != nil {
+		return nil, fmt.Errorf("get price: %s", err.Error())
+	} else {
+		nlp.Item.BigPrice = p.Amount.String()
+		nlp.Item.PriceCurrency = &pb.CurrencyDefinition{
+			Code:         p.Currency.Code.String(),
+			Divisibility: uint32(p.Currency.Divisibility),
+		}
+	}
+
+	if ss, err := l.GetSkus(); err != nil {
+		return nil, fmt.Errorf("get skus: %s", err.Error())
+	} else {
+		nlp.Item.Skus = ss
+	}
+
+	if sos, err := l.GetShippingOptions(); err != nil {
+		return nil, fmt.Errorf("get shipping options: %s", err.Error())
+	} else {
+		nlp.ShippingOptions = sos
+	}
+
+	if cs, err := l.GetCoupons(); err != nil {
+		return nil, fmt.Errorf("get coupons: %s", err.Error())
+	} else {
+		nlp.Coupons = cs.GetProtobuf()
+	}
+
+	return nl, nil
+}
+
 // GetProtobuf returns the current state of pb.Listing managed by Listing
 func (l *Listing) GetProtobuf() *pb.Listing {
 	return l.listingProto
@@ -695,18 +750,18 @@ func (l *Listing) GetImages() []*ListingImage {
 
 // GetSkus returns the listing SKUs
 func (l *Listing) GetSkus() ([]*pb.Listing_Item_Sku, error) {
+	var ss = make([]*pb.Listing_Item_Sku, len(l.listingProto.Item.Skus))
+	for i, s := range l.listingProto.Item.Skus {
+		ss[i] = proto.Clone(s).(*pb.Listing_Item_Sku)
+	}
 	switch l.GetVersion() {
 	case 3, 4:
-		for _, sku := range l.listingProto.Item.Skus {
-			surcharge := new(big.Int).SetInt64(sku.Surcharge)
-			quantity := new(big.Int).SetInt64(sku.Quantity)
-			sku.BigSurcharge = surcharge.String()
-			sku.BigQuantity = quantity.String()
-			sku.Quantity = 0
-			sku.Surcharge = 0
+		for _, sku := range ss {
+			sku.BigSurcharge = big.NewInt(sku.Surcharge).String()
+			sku.BigQuantity = big.NewInt(sku.Quantity).String()
 		}
 	}
-	return l.listingProto.Item.Skus, nil
+	return ss, nil
 }
 
 //GetLanguage return listing's language
@@ -858,6 +913,24 @@ func (l *Listing) GetCoupons() (ListingCoupons, error) {
 // ListingCoupons is a set of listing coupons
 type ListingCoupons []*ListingCoupon
 
+// GetProtobuf converts ListingCoupons into its protobuf representation
+func (cs ListingCoupons) GetProtobuf() []*pb.Listing_Coupon {
+	var cspb = make([]*pb.Listing_Coupon, len(cs))
+	for i, c := range cs {
+		cspb[i] = &pb.Listing_Coupon{
+			Title:            c.GetTitle(),
+			PercentDiscount:  c.GetPercentOff(),
+			BigPriceDiscount: c.GetAmountOff().Amount.String(),
+		}
+		if hash, err := c.GetRedemptionHash(); err == nil {
+			cspb[i].Code = &pb.Listing_Coupon_Hash{Hash: hash}
+		} else if code, err := c.GetRedemptionCode(); err == nil {
+			cspb[i].Code = &pb.Listing_Coupon_DiscountCode{DiscountCode: code}
+		}
+	}
+	return cspb
+}
+
 // ListingCoupon represents an coupon which can be applied to a listing for a discount
 type ListingCoupon struct {
 	listing *Listing
@@ -932,6 +1005,25 @@ func (c *ListingCoupon) updateProtoHash(hash string) error {
 	return errors.New("unable to update missing coupon proto")
 }
 
+// GetShippingOptions returns all shipping options
+func (l *Listing) GetShippingOptions() ([]*pb.Listing_ShippingOption, error) {
+	var so = make([]*pb.Listing_ShippingOption, len(l.listingProto.ShippingOptions))
+	for i, s := range l.listingProto.ShippingOptions {
+		so[i] = proto.Clone(s).(*pb.Listing_ShippingOption)
+	}
+	switch l.GetVersion() {
+	case 3, 4:
+		for _, o := range so {
+			for _, s := range o.Services {
+				s.BigPrice = big.NewInt(int64(s.Price)).String()
+				s.BigAdditionalItemPrice = big.NewInt(int64(s.AdditionalItemPrice)).String()
+			}
+		}
+	}
+	return so, nil
+
+}
+
 // GetShippingRegions returns all region strings for the defined shipping
 // services
 func (l *Listing) GetShippingRegions() ([]string, []string) {

repo/listing_test.go

@@ -2,9 +2,11 @@ package repo_test
 
 import (
 	"bytes"
+	"fmt"
 	"math/big"
 	"testing"
 
+	"github.com/OpenBazaar/openbazaar-go/pb"
 	"github.com/OpenBazaar/openbazaar-go/repo"
 	"github.com/OpenBazaar/openbazaar-go/test/factory"
 )
@@ -209,5 +211,104 @@ func TestListingFromProtobuf(t *testing.T) {
 	if !bytes.Equal(subject.VendorID.BitcoinSig, actual.GetVendorID().BitcoinSignature()) {
 		t.Errorf("expected refund policy to be (%s), but was (%s)", subject.VendorID.BitcoinSig, actual.GetVendorID().BitcoinSignature())
 	}
+}
+
+func TestV4PhysicalGoodDataNormalizesToLatestSchema(t *testing.T) {
+	var (
+		expectedPrice          uint64 = 100000
+		expectedPriceCurrency         = "EUR"
+		expectedSkuSurcharge   int64  = 200
+		expectedSkuQuantity    int64  = 12
+		expectedShippingPrice  uint64 = 30
+		expectedCouponDiscount uint64 = 50
+		v4Proto                       = &pb.Listing{
+			Metadata: &pb.Listing_Metadata{
+				Version:         4,
+				ContractType:    pb.Listing_Metadata_PHYSICAL_GOOD,
+				PricingCurrency: expectedPriceCurrency,
+			},
+			Item: &pb.Listing_Item{
+				Price: expectedPrice,
+				Skus: []*pb.Listing_Item_Sku{
+					{
+						Surcharge: expectedSkuSurcharge,
+						Quantity:  expectedSkuQuantity,
+					},
+				},
+			},
+			ShippingOptions: []*pb.Listing_ShippingOption{
+				{
+					Services: []*pb.Listing_ShippingOption_Service{
+						{
+							Price:               expectedShippingPrice,
+							AdditionalItemPrice: expectedShippingPrice + 1,
+						},
+					},
+				},
+			},
+			Coupons: []*pb.Listing_Coupon{
+				{
+					PriceDiscount: expectedCouponDiscount,
+				},
+			},
+		}
+	)
+
+	l, err := repo.NewListingFromProtobuf(v4Proto)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	nl, err := l.Normalize()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	nlp := nl.GetProtobuf()
+	if v := nlp.Metadata.GetVersion(); v != repo.ListingVersion {
+		t.Errorf("expected version to be (%d), but was (%d)", repo.ListingVersion, v)
+	}
+
+	if p := nlp.Item.BigPrice; p != fmt.Sprintf("%d", expectedPrice) {
+		t.Errorf("expected price to be (%d), but was (%s)", expectedPrice, p)
+	}
 
+	if pc := nlp.Item.PriceCurrency; pc == nil {
+		t.Error("expected to have pricing currency set, but was nil")
+	} else {
+		if pcc := pc.Code; pcc != expectedPriceCurrency {
+			t.Errorf("expected price currency to be (%s), but was (%s)", expectedPriceCurrency, pcc)
+		}
+	}
+
+	if s := nlp.Item.Skus[0]; s == nil {
+		t.Error("expected sku to be present, but was nil")
+	} else {
+		if ss := s.BigSurcharge; ss != fmt.Sprintf("%d", expectedSkuSurcharge) {
+			t.Errorf("expected surcharge to be (%d), but was (%s)", expectedSkuSurcharge, ss)
+		}
+		if sq := s.BigQuantity; sq != fmt.Sprintf("%d", expectedSkuQuantity) {
+			t.Errorf("expected quantity to be (%d), but was (%s)", expectedSkuQuantity, sq)
+		}
+	}
+
+	if s := nlp.ShippingOptions[0]; s == nil {
+		t.Error("expected shipping options to be present, but was nil")
+	} else {
+		if ss := s.Services[0]; ss == nil {
+			t.Error("expected shipping option services to be present, but was nil")
+		} else {
+			if ssp := ss.BigPrice; ssp != fmt.Sprintf("%d", expectedShippingPrice) {
+				t.Errorf("expected shipping option price to be (%d), but was (%s)", expectedShippingPrice, ssp)
+			}
+		}
+	}
+
+	if c := nlp.Coupons[0]; c == nil {
+		t.Error("expected coupon to be present, but was nil")
+	} else {
+		if cd := c.BigPriceDiscount; cd != fmt.Sprintf("%d", expectedCouponDiscount) {
+			t.Errorf("expected coupon discount to be (%d), but was (%s)", expectedCouponDiscount, cd)
+		}
+	}
 }

repo/signed_listing.go

@@ -43,6 +43,19 @@ func (l *SignedListing) Reset()         { *l = SignedListing{} }
 func (l *SignedListing) String() string { return proto.CompactTextString(l) }
 func (*SignedListing) ProtoMessage()    {}
 
+// Normalize is a helper method which will mutate the listing protobuf
+// in-place but maintain the original signature for external verification
+// purposes.
+func (l *SignedListing) Normalize() error {
+	nl, err := l.GetListing().Normalize()
+	if err != nil {
+		return err
+	}
+
+	l.signedListingProto.Listing = nl.listingProto
+	return nil
+}
+
 // GetListing returns the underlying repo.Listing object
 func (l SignedListing) GetListing() *Listing {
 	return &Listing{