Example #1
0
        public static bool IsUpToDate(KitsObject availableKit, ImportedKit importedKit)
        {
            System.Version latestKitVersion = new System.Version (availableKit.Version);
            System.Version currentKitVersion = new System.Version (); // Default is 0.0

            if (importedKit != null) {
                currentKitVersion = importedKit.Instance.Version ();
            }

            return latestKitVersion <= currentKitVersion;
        }
Example #2
0
        public static KitStatus StatusFor(ImportedKit importedKit)
        {
            Settings.InstalledKit installedKit = Settings.Instance.InstalledKits.Find (kit => { return kit.Name == importedKit.Name; });

            if (installedKit == null) {
                return KitStatus.Imported;
            }

            Settings.KitInstallationStatus installationStatus = installedKit.InstallationStatus;

            switch (installationStatus) {
            case Settings.KitInstallationStatus.Configured:
                return KitStatus.Configured;
            case Settings.KitInstallationStatus.Installed:
                return KitStatus.Installed;
            case Settings.KitInstallationStatus.Imported:
            default:
                return KitStatus.Imported;
            }
        }
		private static KeyValuePair<DisplayedKitStatus, Version> DisplayedKitStatusAndVersion(KitsObject kit, ImportedKit imported)
		{
			DisplayedKitStatus kitStatus = DisplayedKitStatus.NotInstalled;
			System.Version kitVersion = new System.Version (kit.Version);
			
			if (imported != null && imported.Status == ImportedKit.InstallationStatus.Installed) {
				kitVersion = imported.Instance.Version ();
				kitStatus = kitVersion < new System.Version (kit.Version) ? DisplayedKitStatus.UpgradeAvailable : DisplayedKitStatus.Installed;
			}

			return new KeyValuePair<DisplayedKitStatus, Version> (kitStatus, kitVersion);
		}
		private Action<KitsObject, ImportedKit, DisplayedKitStatus> SelectKit()
		{
			return delegate(KitsObject availableKit, ImportedKit importedKit, DisplayedKitStatus status) {
				string kitName = importedKit != null ? importedKit.Name : availableKit.Name;

				if (Update.PeriodicUpdateManager.IsPluginUpdateRequired (kitName)) {
					EditorUtility.DisplayDialog (
						"A plugin update is required",
						kitName + " requires a newer version of the Fabric Plugin, please update by clicking 'View Update'.",
						"OK"
					);
					return;
				}

				if (importedKit != null) {
					// If the latest version of a kit is installed, or the latest version is imported into the project,
					// start the normal kit flow.
					if (status == DisplayedKitStatus.Installed || importedKit.Instance.Version () == new System.Version (availableKit.Version)) {
						Settings.Instance.FlowSequence = 0;
						Settings.Instance.Kit = importedKit.Name;
						this.kit = importedKit;
						return;
					}
				}

				// Kit is imported, but not at the latest version, or the kit is not imported. This means
				// we need to download the newest version.
				FabricInstaller.Config config = new FabricInstaller.Config (
					availableKit.PackageUrl,
					availableKit.PackageName,
					availableKit.ReleaseNotesUrl
				);

				kit = null;

				Settings.Instance.FlowSequence = (int)UpdateFlow.Kit;
				Settings.Instance.Kit = kitName;

				List<string> kitsToUpdateDueToDependencies = Update.PeriodicUpdateManager.Resolve (Settings.Instance.Kit);

				if (kitsToUpdateDueToDependencies.Count == 0) {
					ShowUpdatePage (() => { return config; }, UpdateFlow.Kit)();
					return;
				}

				//TODO: implement dependency resolution
				Utils.Log ("There is a dependency issue that needs resolution");
			};
		}
		private void RecreateKitInstance()
		{
			if (kit == null) {
				if (!String.IsNullOrEmpty (Settings.Instance.Kit)) {
					kit = KitUtils.ListImportedKits (Api)().Find (k => k.Name.Equals (Settings.Instance.Kit));
				}
			}
		}
Example #6
0
        private Action<KitsObject, ImportedKit, bool> SelectKit()
        {
            return delegate(KitsObject availableKit, ImportedKit importedKit, bool checkForConflicts) {
                if (Update.PeriodicUpdateManager.IsPluginUpdateRequired (availableKit.Name)) {
                    EditorUtility.DisplayDialog (
                        "A plugin update is required",
                        availableKit.Name + " requires a newer version of the Fabric Plugin, please update by clicking 'View Update'.",
                        "OK"
                    );
                    return;
                }

                Settings.Instance.Kit = availableKit.Name;

                if (importedKit != null && KitUtils.IsUpToDate(availableKit, importedKit)) {
                    // Delegate to the kit's controller.
                    this.kit = importedKit;
                    Settings.Instance.FlowSequence = 0;
                    return;
                }

                // We need to download the latest version of the kit, because it's either not imported or needs updating.

                this.kit = null;
                Settings.Instance.FlowSequence = (int)UpdateFlow.Kit;

                FabricInstaller.Config config = new FabricInstaller.Config (
                    availableKit.PackageUrl,
                    availableKit.PackageName,
                    availableKit.ReleaseNotesUrl
                );

                if (!checkForConflicts || !HasConflictingDependencies (Settings.Instance.Kit)) {
                    ShowUpdatePage (() => { return config; }, UpdateFlow.Kit)();
                    return;
                }

                Settings.Instance.Conflict = Settings.Instance.Kit;
                ShowConflictPage ();
            };
        }
Example #7
0
            public KitRowData(KitsObject availableKit, ImportedKit importedKit)
            {
                this.AvailableKit = availableKit;
                this.ImportedKit = importedKit;

                this.LatestVersion = availableKit.Version.ToString ();
                this.IsUpToDate = KitUtils.IsUpToDate(availableKit, importedKit);

                this.Name = availableKit.Name;
                this.Status = KitStatus.Available;
                this.CurrentVersion = new System.Version ().ToString (); // Default is 0.0

                if (importedKit != null) {
                    this.Name = importedKit.Name;
                    this.Status = KitUtils.StatusFor (importedKit);
                    this.CurrentVersion = importedKit.Instance.Version ().ToString ();
                }
            }