API/Autodoc/Files/DataConverter.cpp.md

---

Source code

// Copyright Epic Games, Inc. All Rights Reserved.

#include "URuStorePaySubscriptionInfo.h"

using namespace RuStoreSDK;
using namespace RuStoreSDK::Pay;

TPair<URuStorePayPurchaseId*, URuStorePayInvoiceId*> DataConverter::ConvertPurchaseEventListenerParams(const FString& purchaseId, const FString& invoiceId)
{
    auto _purchaseId = NewObject<URuStorePayPurchaseId>(GetTransientPackage());
    _purchaseId->value = purchaseId;

    auto _invoiceId = NewObject<URuStorePayInvoiceId>(GetTransientPackage());
    _invoiceId->value = invoiceId;

    return TPair<URuStorePayPurchaseId*, URuStorePayInvoiceId*>(_purchaseId, _invoiceId);
}

const TSharedRef<TArray<FURuStorePayProduct>, ESPMode::ThreadSafe> DataConverter::ParseProducts(const FString& json)
{
    const auto products = MakeShared<TArray<FURuStorePayProduct>, ESPMode::ThreadSafe>();

    TArray<TSharedPtr<FJsonValue>> jsonProducts;
    TSharedRef<TJsonReader<>> reader = TJsonReaderFactory<>::Create(json);
    if (!FJsonSerializer::Deserialize(reader, jsonProducts)) return products;
    
    for (const auto& item : jsonProducts)
    {
        TSharedPtr<FJsonObject> jsonProduct = item->AsObject();
        if (jsonProduct.IsValid())
        {
            FURuStorePayProduct product;
            
            product.amountLabel->value = jsonProduct->GetObjectField("amountLabel")->GetStringField("value");
            product.currency->value = jsonProduct->GetObjectField("currency")->GetStringField("value");
            if (auto field = jsonProduct->GetObjectField("description"))
            {
                product.description = NewObject<URuStorePayDescription>(GetTransientPackage());
                product.description->value = field->GetStringField("value");
            }
            product.imageUrl->value = jsonProduct->GetObjectField("imageUrl")->GetStringField("value");
            if (auto field = jsonProduct->GetObjectField("price"))
            {
                product.price = NewObject<URuStorePayPrice>(GetTransientPackage());
                product.price->value = field->GetIntegerField("value");
            }
            product.productId->value = jsonProduct->GetObjectField("productId")->GetStringField("value");
            if (auto field = jsonProduct->GetObjectField("promoImageUrl"))
            {
                product.promoImageUrl = NewObject<URuStorePayUrl>(GetTransientPackage());
                product.promoImageUrl->value = field->GetStringField("value");
            }
            if (auto field = jsonProduct->GetObjectField("subscriptionInfo"))
            {
                product.subscriptionInfo = NewObject<URuStorePaySubscriptionInfo>(GetTransientPackage());

                auto jsonSubscriptionInfo = jsonProduct->GetObjectField("subscriptionInfo");
                auto jsonPeriods = jsonSubscriptionInfo->GetArrayField("periods");

                for (const auto& jsonPeriod : jsonPeriods)
                {
                    auto jsonPeriodObject = jsonPeriod->AsObject();
                    auto period = ParseSubscriptionPeriod(jsonPeriodObject);

                    product.subscriptionInfo->periods.Add(*period);
                }
            }
            product.title->value = jsonProduct->GetObjectField("title")->GetStringField("value");
            product.type = GetEnumByNameString<EURuStorePayProductType>(jsonProduct->GetStringField("type"));
            
            products->Add(product);
        }
    }

    return products;
}

const TSharedPtr<FURuStorePaySubscriptionPeriod, ESPMode::ThreadSafe> DataConverter::ParseSubscriptionPeriod(TSharedPtr<FJsonObject> jsonSubscriptionPeriod)
{
    const auto period = MakeShared<FURuStorePaySubscriptionPeriod, ESPMode::ThreadSafe>();

    period->periodType = GetEnumByNameString<EURuStorePaySubscriptionPeriodType>(jsonSubscriptionPeriod->GetStringField("simpleName"));
    period->duration = jsonSubscriptionPeriod->GetStringField("duration");
    if (jsonSubscriptionPeriod->HasField("currency")) period->currency = jsonSubscriptionPeriod->GetStringField("currency");
    if (jsonSubscriptionPeriod->HasField("price")) period->price = jsonSubscriptionPeriod->GetIntegerField("price");

    return period;
}

const TSharedPtr<FURuStorePayPurchase, ESPMode::ThreadSafe> DataConverter::ParsePurchase(const FString& json)
{
    TSharedPtr<FJsonObject> jsonPurchase;
    TSharedRef<TJsonReader<>> reader = TJsonReaderFactory<>::Create(json);
    
    return FJsonSerializer::Deserialize(reader, jsonPurchase)
        ? ParsePurchase(jsonPurchase)
        : nullptr;
}

const TSharedPtr<FURuStorePayPurchase, ESPMode::ThreadSafe> DataConverter::ParsePurchase(TSharedPtr<FJsonObject> jsonPurchase)
{
    const auto purchase = MakeShared<FURuStorePayPurchase, ESPMode::ThreadSafe>();

    purchase->productId->value = jsonPurchase->GetObjectField("productId")->GetStringField("value");
    purchase->productType = EURuStorePayProductType::SUBSCRIPTION;
    if (jsonPurchase->HasField("productType"))
    {
        purchase->productType = GetEnumByNameString<EURuStorePayProductType>(jsonPurchase->GetStringField("productType"));
    }
    purchase->purchaseId->value = jsonPurchase->GetObjectField("purchaseId")->GetStringField("value");
    purchase->invoiceId->value = jsonPurchase->GetObjectField("invoiceId")->GetStringField("value");
    if (auto field = jsonPurchase->GetObjectField("orderId"))
    {
        purchase->orderId = NewObject<URuStorePayOrderId>(GetTransientPackage());
        purchase->orderId->value = field->GetStringField("value");
    }
    purchase->purchaseType = GetEnumByNameString<EURuStorePayPurchaseType>(jsonPurchase->GetStringField("purchaseType"));
    purchase->description->value = jsonPurchase->GetObjectField("description")->GetStringField("value");
    if (jsonPurchase->HasField("purchaseTime"))
    {
        purchase->purchaseTime = NewObject<URuStorePayDate>(GetTransientPackage());
        purchase->purchaseTime->value = jsonPurchase->GetStringField("purchaseTime");
    }
    purchase->price->value = jsonPurchase->GetObjectField("price")->GetIntegerField("value");
    purchase->amountLabel->value = jsonPurchase->GetObjectField("amountLabel")->GetStringField("value");
    purchase->currency->value = jsonPurchase->GetObjectField("currency")->GetStringField("value");
    if (auto field = jsonPurchase->GetObjectField("developerPayload"))
    {
        purchase->developerPayload = NewObject<URuStorePayDeveloperPayload>(GetTransientPackage());
        purchase->developerPayload->value = field->GetStringField("value");
    }
    purchase->sandbox = jsonPurchase->GetBoolField("sandbox");
    purchase->acknowledgementState = GetEnumByNameString<EURuStorePayAcknowledgementState>(jsonPurchase->GetStringField("acknowledgementState"));

    switch (purchase->productType)
    {
    case EURuStorePayProductType::NON_CONSUMABLE_PRODUCT:
        purchase->productPurchase = *ParseProductPurchase(jsonPurchase);
        break;
    case EURuStorePayProductType::CONSUMABLE_PRODUCT:
        purchase->productPurchase = *ParseProductPurchase(jsonPurchase);
        break;
    case EURuStorePayProductType::SUBSCRIPTION:
        purchase->subscriptionPurchase = *ParseSubscriptionPurchase(jsonPurchase);
        break;
    }

    return purchase;
}

const TSharedPtr<FURuStorePayProductPurchase, ESPMode::ThreadSafe> DataConverter::ParseProductPurchase(TSharedPtr<FJsonObject> jsonPurchase)
{
    if (!jsonPurchase.IsValid()) return nullptr;

    const auto purchase = MakeShared<FURuStorePayProductPurchase, ESPMode::ThreadSafe>();

    purchase->status = GetEnumByNameString<EURuStorePayProductPurchaseStatus>(jsonPurchase->GetStringField("status"));
    purchase->quantity->value = jsonPurchase->GetObjectField("quantity")->GetIntegerField("value");
    
    return purchase;
}

const TSharedPtr<FURuStorePaySubscriptionPurchase, ESPMode::ThreadSafe> DataConverter::ParseSubscriptionPurchase(TSharedPtr<FJsonObject> jsonPurchase)
{
    if (!jsonPurchase.IsValid()) return nullptr;

    const auto purchase = MakeShared<FURuStorePaySubscriptionPurchase, ESPMode::ThreadSafe>();

    purchase->status = GetEnumByNameString<EURuStorePaySubscriptionPurchaseStatus>(jsonPurchase->GetStringField("status"));
    purchase->gracePeriodEnabled = jsonPurchase->GetBoolField("gracePeriodEnabled");
    
    purchase->expirationDate = NewObject<URuStorePayDate>(GetTransientPackage());
    purchase->expirationDate->value = jsonPurchase->GetStringField("expirationDate");
    
    return purchase;
}

const TSharedRef<TArray<FURuStorePayPurchase>, ESPMode::ThreadSafe> DataConverter::ParsePurchases(const FString& json)
{
    const auto purchases = MakeShared<TArray<FURuStorePayPurchase>, ESPMode::ThreadSafe>();

    TArray<TSharedPtr<FJsonValue>> jsonPurchases;
    TSharedRef<TJsonReader<>> reader = TJsonReaderFactory<>::Create(json);
    if (!FJsonSerializer::Deserialize(reader, jsonPurchases)) return purchases;

    for (const auto& item : jsonPurchases)
    {
        if (!item.IsValid()) continue;

        auto jsonPurchase = item->AsObject();
        if (!jsonPurchase.IsValid()) continue;

        auto purchase = ParsePurchase(jsonPurchase);
        if (!purchase.IsValid()) continue;

        purchases->Add(*purchase);
    }

    return purchases;
}

const TSharedPtr<FURuStorePayProductPurchaseResult, ESPMode::ThreadSafe> DataConverter::ParsePurchaseResult(const FString& json)
{
    TSharedPtr<FJsonObject> jsonResult;
    TSharedRef<TJsonReader<>> reader = TJsonReaderFactory<>::Create(json);
    if (!FJsonSerializer::Deserialize(reader, jsonResult) || !jsonResult.IsValid()) return nullptr;

    const auto result = MakeShared<FURuStorePayProductPurchaseResult, ESPMode::ThreadSafe>();

    result->invoiceId->value = jsonResult->GetObjectField("invoiceId")->GetStringField("value");
    if (auto field = jsonResult->GetObjectField("orderId"))
    {
        result->orderId = NewObject<URuStorePayOrderId>(GetTransientPackage());
        result->orderId->value = field->GetStringField("value");
    }
    result->productId->value = jsonResult->GetObjectField("productId")->GetStringField("value");
    result->productType = GetEnumByNameString<EURuStorePayProductType>(jsonResult->GetStringField("productType"));
    result->purchaseId->value = jsonResult->GetObjectField("purchaseId")->GetStringField("value");
    result->purchaseType = GetEnumByNameString<EURuStorePayPurchaseType>(jsonResult->GetStringField("purchaseType"));
    result->quantity->value = jsonResult->GetObjectField("quantity")->GetIntegerField("value");
    result->sandbox = jsonResult->GetBoolField("sandbox");

    return result;
}

const FString DataConverter::PurchaseStatusFilterToString(EURuStorePayPurchaseStatusFilter status)
{
    switch (status)
    {
        case EURuStorePayPurchaseStatusFilter::PAID:
            return "ProductPurchaseStatus.PAID";
        case EURuStorePayPurchaseStatusFilter::CONFIRMED:
            return "ProductPurchaseStatus.CONFIRMED";
        case EURuStorePayPurchaseStatusFilter::ACTIVE:
            return "SubscriptionPurchaseStatus.ACTIVE";
        case EURuStorePayPurchaseStatusFilter::PAUSED:
            return "SubscriptionPurchaseStatus.PAUSED";
        default:
            return "";
    }
}

---