< 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:48
Uncovered lines:63
Coverable lines:111
Total lines:260
Line coverage:43.2% (48 of 111)
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%19.126028.57%
DCL-Helpers-NFT-Markets-INFTMarket-FetchNFTInfo()0%6.116085.71%
DCL-Helpers-NFT-Markets-INFTMarket-FetchNFTInfoSingleAsset()0%42600%
ResponseToNFTOwner(...)0%6200%
ResponseToNFTInfo(...)0%9.039093.1%
ResponseToNFTInfo(...)0%42600%
PriceToFloatingPointString(...)0%2.152066.67%
PriceToFloatingPointString(...)0%3.213071.43%
GetSellOrder(...)0%12.194020%
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;
 5
 6namespace DCL.Helpers.NFT.Markets
 7{
 8    public class OpenSea : INFTMarket
 9    {
 67110        readonly MarketInfo openSeaMarketInfo = new MarketInfo() { name = "OpenSea" };
 11
 67112        private readonly RequestController requestController = new RequestController();
 13
 14        IEnumerator INFTMarket.FetchNFTsFromOwner(string address, Action<NFTOwner> onSuccess, Action<string> onError)
 15        {
 416            var request = requestController.FetchOwnedNFT(address);
 17
 3418            yield return new UnityEngine.WaitUntil(() => !request.pending);
 19
 020            if (request.resolved)
 21            {
 022                onSuccess?.Invoke( ResponseToNFTOwner(address, request.resolvedValue));
 023            }
 24            else
 25            {
 026                onError?.Invoke(request.error);
 27            }
 028        }
 29
 30        IEnumerator INFTMarket.FetchNFTInfo(string assetContractAddress, string tokenId, Action<NFTInfo> onSuccess, Acti
 31        {
 832            var request = requestController.FetchNFT(assetContractAddress, tokenId);
 33
 298434            yield return new UnityEngine.WaitUntil(() => !request.pending);
 35
 736            if (request.resolved)
 37            {
 738                onSuccess?.Invoke( ResponseToNFTInfo(request.resolvedValue));
 739            }
 40            else
 41            {
 042                onError?.Invoke(request.error);
 43            }
 744        }
 45
 46        IEnumerator INFTMarket.FetchNFTInfoSingleAsset(string assetContractAddress, string tokenId, Action<NFTInfoSingle
 47        {
 048            var request = requestController.FetchSingleNFT(assetContractAddress, tokenId);
 49
 050            yield return new UnityEngine.WaitUntil(() => !request.pending);
 51
 052            if (request.resolved)
 53            {
 054                onSuccess?.Invoke( ResponseToNFTInfo(request.resolvedValue));
 055            }
 56            else
 57            {
 058                onError?.Invoke(request.error);
 59            }
 060        }
 61
 62        private NFTOwner ResponseToNFTOwner(string ethAddress, AssetsResponse response)
 63        {
 064            NFTOwner ownerInfo = NFTOwner.defaultNFTOwner;
 065            ownerInfo.ethAddress = ethAddress;
 66
 067            foreach (AssetResponse assetResponse in response.assets)
 68            {
 069                ownerInfo.assets.Add(ResponseToNFTInfo(assetResponse));
 70            }
 71
 072            return ownerInfo;
 73        }
 74
 75        private NFTInfo ResponseToNFTInfo(AssetResponse response)
 76        {
 777            NFTInfo ret = NFTInfo.defaultNFTInfo;
 778            ret.marketInfo = openSeaMarketInfo;
 779            ret.name = response.name;
 780            ret.description = response.description;
 781            ret.thumbnailUrl = response.image_thumbnail_url;
 782            ret.previewImageUrl = response.image_preview_url;
 783            ret.originalImageUrl = response.image_original_url;
 784            ret.imageUrl = response.image_url;
 785            ret.assetLink = response.external_link;
 786            ret.marketLink = response.permalink;
 787            ret.tokenId = response.token_id;
 88
 789            ret.assetContract.address = response.asset_contract.address;
 790            ret.assetContract.name = response.asset_contract.name;
 91
 792            if (!string.IsNullOrEmpty(response.owner?.address))
 93            {
 794                ret.owner = response.owner.address;
 95            }
 96
 797            if (response.num_sales != null)
 98            {
 799                ret.numSales = response.num_sales.Value;
 100            }
 101
 7102            if (response.last_sale != null)
 103            {
 7104                ret.lastSaleDate = response.last_sale.event_timestamp;
 105
 7106                if (response.last_sale.payment_token != null)
 107                {
 7108                    ret.lastSaleAmount = PriceToFloatingPointString(response.last_sale);
 7109                    ret.lastSaleToken = new NFT.PaymentTokenInfo()
 110                    {
 111                        symbol = response.last_sale.payment_token.symbol
 112                    };
 113                }
 114            }
 115
 116            UnityEngine.Color backgroundColor;
 7117            if (UnityEngine.ColorUtility.TryParseHtmlString("#" + response.background_color, out backgroundColor))
 118            {
 7119                ret.backgroundColor = backgroundColor;
 120            }
 121
 7122            OrderInfo sellOrder = GetSellOrder(response.sell_orders, response.owner.address);
 7123            if (sellOrder != null)
 124            {
 0125                ret.currentPrice = PriceToFloatingPointString(sellOrder.current_price, sellOrder.payment_token_contract)
 0126                ret.currentPriceToken = new NFT.PaymentTokenInfo()
 127                {
 128                    symbol = sellOrder.payment_token_contract.symbol
 129                };
 130            }
 131
 7132            return ret;
 133        }
 134
 135        private NFTInfoSingleAsset ResponseToNFTInfo(SingleAssetResponse response)
 136        {
 0137            NFTInfoSingleAsset ret = NFTInfoSingleAsset.defaultNFTInfoSingleAsset;
 0138            ret.tokenId = response.token_id;
 0139            ret.marketInfo = openSeaMarketInfo;
 0140            ret.name = response.name;
 0141            ret.description = response.description;
 0142            ret.previewImageUrl = response.image_preview_url;
 0143            ret.originalImageUrl = response.image_original_url;
 0144            ret.assetLink = response.external_link;
 0145            ret.marketLink = response.permalink;
 146
 0147            ret.assetContract.address = response.asset_contract.address;
 0148            ret.assetContract.name = response.asset_contract.name;
 149
 0150            if (response.last_sale != null)
 151            {
 0152                ret.lastSaleDate = response.last_sale.event_timestamp;
 153
 0154                if (response.last_sale.payment_token != null)
 155                {
 0156                    ret.lastSaleAmount = PriceToFloatingPointString(response.last_sale);
 0157                    ret.lastSaleToken = new NFT.PaymentTokenInfo()
 158                    {
 159                        symbol = response.last_sale.payment_token.symbol
 160                    };
 161                }
 162            }
 163
 164            UnityEngine.Color backgroundColor;
 0165            if (UnityEngine.ColorUtility.TryParseHtmlString("#" + response.background_color, out backgroundColor))
 166            {
 0167                ret.backgroundColor = backgroundColor;
 168            }
 169
 0170            OrderInfo sellOrder = GetSellOrder(response.orders, response.top_ownerships);
 0171            if (sellOrder != null)
 172            {
 0173                ret.currentPrice = PriceToFloatingPointString(sellOrder.current_price, sellOrder.payment_token_contract)
 0174                ret.currentPriceToken = new NFT.PaymentTokenInfo()
 175                {
 176                    symbol = sellOrder.payment_token_contract.symbol
 177                };
 178            }
 179
 0180            ret.owners = new NFTInfoSingleAsset.Owners[response.top_ownerships.Length];
 0181            for (int i = 0; i < response.top_ownerships.Length; i++)
 182            {
 0183                ret.owners[i] = new NFTInfoSingleAsset.Owners()
 184                {
 185                    owner = response.top_ownerships[i].owner.address,
 186                };
 187
 0188                float.TryParse(response.top_ownerships[i].quantity, out float quantity);
 0189                ret.owners[i].quantity = quantity;
 190            }
 191
 0192            return ret;
 193        }
 194
 195        private string PriceToFloatingPointString(OpenSea_Internal.AssetSaleInfo saleInfo)
 196        {
 7197            if (saleInfo.payment_token == null)
 0198                return null;
 7199            return PriceToFloatingPointString(saleInfo.total_price, saleInfo.payment_token);
 200        }
 201
 202        private string PriceToFloatingPointString(string price, OpenSea_Internal.PaymentTokenInfo tokenInfo)
 203        {
 7204            string priceString = price;
 7205            if (price.Contains('.'))
 206            {
 0207                priceString = price.Split('.')[0];
 208            }
 209
 7210            int pointPosition = priceString.Length - tokenInfo.decimals;
 7211            if (pointPosition <= 0)
 212            {
 7213                return "0." + string.Concat(Enumerable.Repeat("0", Math.Abs(pointPosition))) + priceString;
 214            }
 215            else
 216            {
 0217                return priceString.Insert(pointPosition, ".");
 218            }
 219        }
 220
 221        private OrderInfo GetSellOrder(OrderInfo[] orders, string nftOwner)
 222        {
 7223            if (orders == null)
 7224                return null;
 225
 0226            OrderInfo ret = null;
 0227            for (int i = 0; i < orders.Length; i++)
 228            {
 0229                if (orders[i].maker.address == nftOwner)
 230                {
 0231                    ret = orders[i];
 0232                    break;
 233                }
 234            }
 235
 0236            return ret;
 237        }
 238
 239        private OrderInfo GetSellOrder(OrderInfo[] orders, OwnershipInfo[] owners)
 240        {
 0241            if (orders == null)
 0242                return null;
 243
 0244            for (int i = 0; i < orders.Length; i++)
 245            {
 0246                if (owners.Any(ownerInfo => orders[i].maker.address == ownerInfo.owner.address))
 247                {
 0248                    return orders[i];
 249                }
 250            }
 251
 0252            return null;
 253        }
 254
 255        public void Dispose()
 256        {
 692257            requestController?.Dispose();
 692258        }
 259    }
 260}
Generated by: ReportGenerator 4.8.9.0
10/18/2021 - 20:28:19
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()