public AssetStorePackage(AssetStoreFetchedInfo fetchedInfo, UpmPackage package)
        {
            m_Errors    = new List <Error>();
            m_Progress  = PackageProgress.None;
            m_Type      = PackageType.AssetStore;
            m_Name      = package?.name ?? string.Empty;
            m_ProductId = fetchedInfo?.id.ToString();

            m_Images      = fetchedInfo?.images ?? new List <PackageImage>();
            m_Links       = fetchedInfo?.links ?? new List <PackageLink>();
            m_VersionList = new AssetStoreVersionList();

            m_UpmVersionList = package?.versions as UpmVersionList ?? new UpmVersionList();
            foreach (var version in m_UpmVersionList.Cast <UpmPackageVersion>())
            {
                version.UpdateFetchedInfo(fetchedInfo);
            }

            if (string.IsNullOrEmpty(fetchedInfo?.id) || string.IsNullOrEmpty(fetchedInfo?.versionId))
            {
                AddError(new Error(NativeErrorCode.Unknown, "Invalid product details."));
            }
            else if (string.IsNullOrEmpty(package?.name))
            {
                AddError(new Error(NativeErrorCode.Unknown, "Invalid package info."));
            }
        }
        public AssetStorePackage(AssetStoreFetchedInfo fetchedInfo, AssetStoreLocalInfo localInfo = null)
        {
            m_Errors         = new List <Error>();
            m_Progress       = PackageProgress.None;
            m_Type           = PackageType.AssetStore;
            m_Name           = string.Empty;
            m_ProductId      = fetchedInfo?.id.ToString();
            m_Images         = fetchedInfo?.images ?? new List <PackageImage>();
            m_Links          = fetchedInfo?.links ?? new List <PackageLink>();
            m_VersionList    = new AssetStoreVersionList();
            m_UpmVersionList = new UpmVersionList();

            if (string.IsNullOrEmpty(fetchedInfo?.id) || string.IsNullOrEmpty(fetchedInfo?.versionId))
            {
                AddError(new Error(NativeErrorCode.Unknown, "Invalid product details."));
            }
            else if (localInfo == null)
            {
                m_VersionList.AddVersion(new AssetStorePackageVersion(fetchedInfo));
            }
            else
            {
                m_VersionList.AddVersion(new AssetStorePackageVersion(fetchedInfo, localInfo));
                if (localInfo.canUpdate && (localInfo.versionId != fetchedInfo.versionId || localInfo.versionString != fetchedInfo.versionString))
                {
                    m_VersionList.AddVersion(new AssetStorePackageVersion(fetchedInfo));
                }
            }
        }
            public void FetchDetails(IEnumerable <long> productIds)
            {
                var countProduct = productIds.Count();

                if (countProduct == 0)
                {
                    return;
                }

                onFetchDetailsStart?.Invoke();

                foreach (var id in productIds)
                {
                    AssetStoreRestAPI.instance.GetProductDetail(id, productDetail =>
                    {
                        AssetStorePackage package = null;
                        var error = productDetail.GetString("errorMessage");
                        if (string.IsNullOrEmpty(error))
                        {
                            var fetchedInfo = AssetStoreFetchedInfo.ParseFetchedInfo(id.ToString(), productDetail);
                            if (fetchedInfo == null)
                            {
                                package = new AssetStorePackage(id.ToString(), new Error(NativeErrorCode.Unknown, "Error parsing product details."));
                            }
                            else
                            {
                                var oldFetchedInfo = m_FetchedInfos.Get(fetchedInfo.id);
                                if (oldFetchedInfo == null || oldFetchedInfo.versionId != fetchedInfo.versionId || oldFetchedInfo.versionString != fetchedInfo.versionString)
                                {
                                    if (string.IsNullOrEmpty(fetchedInfo.packageName))
                                    {
                                        package = new AssetStorePackage(fetchedInfo, m_LocalInfos.Get(fetchedInfo.id));
                                    }
                                    else
                                    {
                                        UpmClient.instance.FetchForProduct(fetchedInfo.id, fetchedInfo.packageName);
                                    }
                                    m_FetchedInfos[fetchedInfo.id] = fetchedInfo;
                                }
                            }
                        }
                        else
                        {
                            package = new AssetStorePackage(id.ToString(), new Error(NativeErrorCode.Unknown, error));
                        }

                        if (package != null)
                        {
                            onPackagesChanged?.Invoke(new[] { package });
                        }

                        countProduct--;
                        if (countProduct == 0)
                        {
                            onFetchDetailsFinish?.Invoke();
                        }
                    });
                }
            }
Exemple #4
0
        internal void UpdateFetchedInfo(AssetStoreFetchedInfo fetchedInfo)
        {
            m_PackageUniqueId = fetchedInfo.id;

            // override version info with product info
            m_DisplayName = fetchedInfo.displayName;
            m_Description = fetchedInfo.description;
        }
        public AssetStorePackageVersion(AssetStoreFetchedInfo fetchedInfo, AssetStoreLocalInfo localInfo = null)
        {
            if (fetchedInfo == null)
            {
                throw new ArgumentNullException(nameof(fetchedInfo));
            }

            m_Errors          = new List <Error>();
            m_Tag             = PackageTag.Downloadable | PackageTag.Importable;
            m_PackageUniqueId = fetchedInfo.id;

            m_Description = fetchedInfo.description;
            m_Author      = fetchedInfo.author;
            m_PublisherId = fetchedInfo.publisherId;

            m_Category = fetchedInfo.category;

            m_VersionString = localInfo?.versionString ?? fetchedInfo.versionString ?? string.Empty;
            m_VersionId     = localInfo?.versionId ?? fetchedInfo.versionId ?? string.Empty;
            SemVersionParser.TryParse(m_VersionString.Trim(), out m_Version);

            var publishDateString = localInfo?.publishedDate ?? fetchedInfo.publishedDate ?? string.Empty;

            m_PublishedDateTicks = !string.IsNullOrEmpty(publishDateString) ? DateTime.Parse(publishDateString).Ticks : 0;
            m_DisplayName        = !string.IsNullOrEmpty(fetchedInfo.displayName) ? fetchedInfo.displayName : $"Package {m_PackageUniqueId}@{m_VersionId}";

            m_SupportedUnityVersions = new List <SemVersion>();
            if (localInfo != null)
            {
                var simpleVersion = Regex.Replace(localInfo.supportedVersion, @"(?<major>\d+)\.(?<minor>\d+).(?<patch>\d+)[abfp].+", "${major}.${minor}.${patch}");
                SemVersionParser.TryParse(simpleVersion.Trim(), out m_SupportedUnityVersion);
                m_SupportedUnityVersionString = m_SupportedUnityVersion?.ToString();
            }
            else if (fetchedInfo.supportedVersions?.Any() ?? false)
            {
                foreach (var supportedVersion in fetchedInfo.supportedVersions)
                {
                    SemVersion?version;
                    bool       isVersionParsed = SemVersionParser.TryParse(supportedVersion as string, out version);

                    if (isVersionParsed)
                    {
                        m_SupportedUnityVersions.Add((SemVersion)version);
                    }
                }

                m_SupportedUnityVersions.Sort((left, right) => (left).CompareTo(right));
                m_SupportedUnityVersion       = m_SupportedUnityVersions.LastOrDefault();
                m_SupportedUnityVersionString = m_SupportedUnityVersion?.ToString();
            }

            m_SizeInfos = new List <PackageSizeInfo>(fetchedInfo.sizeInfos);
            m_SizeInfos.Sort((left, right) => left.supportedUnityVersion.CompareTo(right.supportedUnityVersion));

            var state = fetchedInfo.state ?? string.Empty;

            if (state.Equals("published", StringComparison.InvariantCultureIgnoreCase))
            {
                m_Tag |= PackageTag.Published;
            }
            else if (state.Equals("deprecated", StringComparison.InvariantCultureIgnoreCase))
            {
                m_Tag |= PackageTag.Deprecated;
            }

            SetLocalPath(localInfo?.packagePath);
        }