< Summary

Class:DCL.Helpers.NFT.Markets.OpenSea
Assembly:OpenSea_Internal
File(s):/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/MainScripts/DCL/ServiceProviders/OpenSea/OpenSea.cs
Covered lines:4
Uncovered lines:102
Coverable lines:106
Total lines:256
Line coverage:3.7% (4 of 106)
Covered branches:0
Total branches:0

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
OpenSea()0%110100%
DCL-Helpers-NFT-Markets-INFTMarket-FetchNFTsFromOwner()0%42600%
DCL-Helpers-NFT-Markets-INFTMarket-FetchNFTInfo()0%42600%
DCL-Helpers-NFT-Markets-INFTMarket-FetchNFTInfoSingleAsset()0%42600%
ResponseToNFTOwner(...)0%6200%
ResponseToNFTInfo(...)0%42600%
ResponseToNFTInfo(...)0%42600%
PriceToFloatingPointString(...)0%6200%
PriceToFloatingPointString(...)0%12300%
GetSellOrder(...)0%20400%
GetSellOrder(...)0%30500%
Dispose()0%220100%

File(s)

/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/MainScripts/DCL/ServiceProviders/OpenSea/OpenSea.cs

#LineLine coverage
 1using System;
 2using System.Collections;
 3using System.Linq;
 4using DCL.Helpers.NFT.Markets.OpenSea_Internal;
 5using UnityEngine;
 6
 7namespace DCL.Helpers.NFT.Markets
 8{
 9    public class OpenSea : INFTMarket
 10    {
 12211        readonly MarketInfo openSeaMarketInfo = new MarketInfo() { name = "OpenSea" };
 12
 12213        private readonly RequestController requestController = new RequestController();
 14
 15        IEnumerator INFTMarket.FetchNFTsFromOwner(string address, Action<NFTOwner> onSuccess, Action<string> onError)
 16        {
 017            var request = requestController.FetchOwnedNFT(address);
 18
 019            yield return new UnityEngine.WaitUntil(() => !request.pending);
 20
 021            if (request.resolved)
 22            {
 023                onSuccess?.Invoke( ResponseToNFTOwner(address, request.resolvedValue));
 24            }
 25            else
 26            {
 027                onError?.Invoke(request.error);
 28            }
 029        }
 30
 31        IEnumerator INFTMarket.FetchNFTInfo(string assetContractAddress, string tokenId, Action<NFTInfo> onSuccess, Acti
 32        {
 033            RequestBase<AssetResponse> request = requestController.FetchNFT(assetContractAddress, tokenId);
 34
 035            yield return new UnityEngine.WaitUntil(() => !request.pending);
 36
 037            if (request.resolved)
 38            {
 039                onSuccess?.Invoke( ResponseToNFTInfo(request.resolvedValue));
 40            }
 41            else
 42            {
 043                onError?.Invoke(request.error);
 44            }
 045        }
 46
 47        IEnumerator INFTMarket.FetchNFTInfoSingleAsset(string assetContractAddress, string tokenId, Action<NFTInfoSingle
 48        {
 049            RequestBase<SingleAssetResponse> request = requestController.FetchSingleNFT(assetContractAddress, tokenId);
 50
 051            yield return new UnityEngine.WaitUntil(() => !request.pending);
 52
 053            if (request.resolved)
 54            {
 055                onSuccess?.Invoke( ResponseToNFTInfo(request.resolvedValue));
 56            }
 57            else
 58            {
 059                onError?.Invoke(request.error);
 60            }
 061        }
 62
 63        private NFTOwner ResponseToNFTOwner(string ethAddress, AssetsResponse response)
 64        {
 065            NFTOwner ownerInfo = NFTOwner.defaultNFTOwner;
 066            ownerInfo.ethAddress = ethAddress;
 67
 068            foreach (AssetResponse assetResponse in response.assets)
 69            {
 070                ownerInfo.assets.Add(ResponseToNFTInfo(assetResponse));
 71            }
 72
 073            return ownerInfo;
 74        }
 75
 76        private NFTInfo ResponseToNFTInfo(AssetResponse response)
 77        {
 078            NFTInfo ret = NFTInfo.defaultNFTInfo;
 079            ret.marketInfo = openSeaMarketInfo;
 080            ret.name = response.name;
 081            ret.description = response.description;
 082            ret.thumbnailUrl = response.image_thumbnail_url;
 083            ret.previewImageUrl = response.image_preview_url;
 084            ret.originalImageUrl = response.image_original_url;
 085            ret.imageUrl = response.image_url;
 086            ret.assetLink = response.external_link;
 087            ret.marketLink = response.permalink;
 088            ret.tokenId = response.token_id;
 89
 090            ret.assetContract.address = response.asset_contract.address;
 091            ret.assetContract.name = response.asset_contract.name;
 92
 093            if (response.num_sales != null)
 94            {
 095                ret.numSales = response.num_sales.Value;
 96            }
 97
 098            if (response.last_sale != null)
 99            {
 0100                ret.lastSaleDate = response.last_sale.event_timestamp;
 101
 0102                if (response.last_sale.payment_token != null)
 103                {
 0104                    ret.lastSaleAmount = PriceToFloatingPointString(response.last_sale);
 0105                    ret.lastSaleToken = new NFT.PaymentTokenInfo()
 106                    {
 107                        symbol = response.last_sale.payment_token.symbol
 108                    };
 109                }
 110            }
 111
 112            UnityEngine.Color backgroundColor;
 0113            if (UnityEngine.ColorUtility.TryParseHtmlString("#" + response.background_color, out backgroundColor))
 114            {
 0115                ret.backgroundColor = backgroundColor;
 116            }
 117
 0118            OrderInfo sellOrder = GetSellOrder(response.sell_orders, response.top_ownerships);
 0119            if (sellOrder != null)
 120            {
 0121                ret.currentPrice = PriceToFloatingPointString(sellOrder.current_price, sellOrder.payment_token_contract)
 0122                ret.currentPriceToken = new NFT.PaymentTokenInfo()
 123                {
 124                    symbol = sellOrder.payment_token_contract.symbol
 125                };
 126            }
 127
 0128            return ret;
 129        }
 130
 131        private NFTInfoSingleAsset ResponseToNFTInfo(SingleAssetResponse response)
 132        {
 0133            NFTInfoSingleAsset ret = NFTInfoSingleAsset.defaultNFTInfoSingleAsset;
 0134            ret.tokenId = response.token_id;
 0135            ret.marketInfo = openSeaMarketInfo;
 0136            ret.name = response.name;
 0137            ret.description = response.description;
 0138            ret.previewImageUrl = response.image_preview_url;
 0139            ret.originalImageUrl = response.image_original_url;
 0140            ret.assetLink = response.external_link;
 0141            ret.marketLink = response.permalink;
 142
 0143            ret.assetContract.address = response.asset_contract.address;
 0144            ret.assetContract.name = response.asset_contract.name;
 145
 0146            if (response.last_sale != null)
 147            {
 0148                ret.lastSaleDate = response.last_sale.event_timestamp;
 149
 0150                if (response.last_sale.payment_token != null)
 151                {
 0152                    ret.lastSaleAmount = PriceToFloatingPointString(response.last_sale);
 0153                    ret.lastSaleToken = new NFT.PaymentTokenInfo()
 154                    {
 155                        symbol = response.last_sale.payment_token.symbol
 156                    };
 157                }
 158            }
 159
 160            UnityEngine.Color backgroundColor;
 0161            if (UnityEngine.ColorUtility.TryParseHtmlString("#" + response.background_color, out backgroundColor))
 162            {
 0163                ret.backgroundColor = backgroundColor;
 164            }
 165
 0166            OrderInfo sellOrder = GetSellOrder(response.orders, response.top_ownerships);
 0167            if (sellOrder != null)
 168            {
 0169                ret.currentPrice = PriceToFloatingPointString(sellOrder.current_price, sellOrder.payment_token_contract)
 0170                ret.currentPriceToken = new NFT.PaymentTokenInfo()
 171                {
 172                    symbol = sellOrder.payment_token_contract.symbol
 173                };
 174            }
 175
 0176            ret.owners = new NFTInfoSingleAsset.Owners[response.top_ownerships.Length];
 0177            for (int i = 0; i < response.top_ownerships.Length; i++)
 178            {
 0179                ret.owners[i] = new NFTInfoSingleAsset.Owners()
 180                {
 181                    owner = response.top_ownerships[i].owner.address,
 182                };
 183
 0184                float.TryParse(response.top_ownerships[i].quantity, out float quantity);
 0185                ret.owners[i].quantity = quantity;
 186            }
 187
 0188            return ret;
 189        }
 190
 191        private string PriceToFloatingPointString(OpenSea_Internal.AssetSaleInfo saleInfo)
 192        {
 0193            if (saleInfo.payment_token == null)
 0194                return null;
 0195            return PriceToFloatingPointString(saleInfo.total_price, saleInfo.payment_token);
 196        }
 197
 198        private string PriceToFloatingPointString(string price, OpenSea_Internal.PaymentTokenInfo tokenInfo)
 199        {
 0200            string priceString = price;
 0201            if (price.Contains('.'))
 202            {
 0203                priceString = price.Split('.')[0];
 204            }
 205
 0206            int pointPosition = priceString.Length - tokenInfo.decimals;
 0207            if (pointPosition <= 0)
 208            {
 0209                return "0." + string.Concat(Enumerable.Repeat("0", Math.Abs(pointPosition))) + priceString;
 210            }
 211            else
 212            {
 0213                return priceString.Insert(pointPosition, ".");
 214            }
 215        }
 216
 217        private OrderInfo GetSellOrder(OrderInfo[] orders, string nftOwner)
 218        {
 0219            if (orders == null)
 0220                return null;
 221
 0222            OrderInfo ret = null;
 0223            for (int i = 0; i < orders.Length; i++)
 224            {
 0225                if (orders[i].maker.address == nftOwner)
 226                {
 0227                    ret = orders[i];
 0228                    break;
 229                }
 230            }
 231
 0232            return ret;
 233        }
 234
 235        private OrderInfo GetSellOrder(OrderInfo[] orders, OwnershipInfo[] owners)
 236        {
 0237            if (orders == null)
 0238                return null;
 239
 0240            for (int i = 0; i < orders.Length; i++)
 241            {
 0242                if (owners.Any(ownerInfo => orders[i].maker.address == ownerInfo.owner.address))
 243                {
 0244                    return orders[i];
 245                }
 246            }
 247
 0248            return null;
 249        }
 250
 251        public void Dispose()
 252        {
 122253            requestController?.Dispose();
 122254        }
 255    }
 256}
Generated by: ReportGenerator 4.8.9.0
02/03/2023 - 18:35:21
GitHub | www.palmmedia.de

Methods/Properties

OpenSea()
DCL-Helpers-NFT-Markets-INFTMarket-FetchNFTsFromOwner()
DCL-Helpers-NFT-Markets-INFTMarket-FetchNFTInfo()
DCL-Helpers-NFT-Markets-INFTMarket-FetchNFTInfoSingleAsset()
ResponseToNFTOwner(System.String, DCL.Helpers.NFT.Markets.OpenSea_Internal.AssetsResponse)
ResponseToNFTInfo(DCL.Helpers.NFT.Markets.OpenSea_Internal.AssetResponse)
ResponseToNFTInfo(DCL.Helpers.NFT.Markets.OpenSea_Internal.SingleAssetResponse)
PriceToFloatingPointString(DCL.Helpers.NFT.Markets.OpenSea_Internal.AssetSaleInfo)
PriceToFloatingPointString(System.String, DCL.Helpers.NFT.Markets.OpenSea_Internal.PaymentTokenInfo)
GetSellOrder(DCL.Helpers.NFT.Markets.OpenSea_Internal.OrderInfo[], System.String)
GetSellOrder(DCL.Helpers.NFT.Markets.OpenSea_Internal.OrderInfo[], DCL.Helpers.NFT.Markets.OpenSea_Internal.OwnershipInfo[])
Dispose()