public override MigrationResult Migrate(DatabaseStatus preSchemaUpdateStatus)
        {
            var alreadyUpdated = new HashSet<string>();

            int updatedItems = 0;
            using (var transaction = repository.BeginTransaction())
            {
                var detailsWithImages = repository.Find(
                    Parameter.Equal("ValueTypeKey", "String"),
                    Parameter.Like("StringValue", "%<img%")
                );

                foreach (var detail in detailsWithImages)
                {
                    if (alreadyUpdated.Contains(detail.EnclosingItem.Name))
                        continue;

                    alreadyUpdated.Add(detail.EnclosingItem.Name);
                    linkTracker.UpdateLinks(detail.EnclosingItem);
                    itemRepository.SaveOrUpdate(detail.EnclosingItem);
                    updatedItems++;
                }

                repository.Flush();
                transaction.Commit();
            }

            return new MigrationResult(this) { UpdatedItems = updatedItems };
        }

        public override MigrationResult Migrate(DatabaseStatus preSchemaUpdateStatus)
        {
            int updatedItems = 0;
            using (var tx = repository.BeginTransaction())
            {
                var itemsWithUntrackedLinks = repository.Find(Parameter.Like(null, "%/upload/%").Detail() & Parameter.IsNull("TrackedLinks").Detail());
                foreach (var item in itemsWithUntrackedLinks)
                {
                    tracker.UpdateLinks(item);
                    repository.SaveOrUpdate(item);
                    updatedItems++;
                }
                tx.Commit();
            }

            var path = config.UploadFolders.AllElements.Where(uf => !string.IsNullOrEmpty(uf.UrlPrefix)).Select(uf => uf.Path).FirstOrDefault();
            path = Url.ToAbsolute(path);

            return new MigrationResult(this) 
            {
                UpdatedItems = updatedItems,
                RedirectTo = "{ManagementUrl}/Content/LinkTracker/UpdateReferences.aspx"
                    + "?selectedUrl=" + path 
                    + "&previousUrl=" +  path
                    + "&location=upgrade"
            };
        }

 public override MigrationResult Migrate(DatabaseStatus preSchemaUpdateStatus)
 {
     if (IsApplicable(preSchemaUpdateStatus))
         return new MigrationResult(this) { RedirectTo = "UpgradeVersions.aspx" };
     else
         return new MigrationResult(this);
 }

		public override bool IsApplicable(DatabaseStatus status)
		{
			return status.DatabaseVersion < DatabaseStatus.RequiredDatabaseVersion 
				|| !status.HasSchema 
				|| repository.Find("State", ContentState.None).Any()
				|| repository.Find("State", ContentState.New).Any();
		}

        public static bool UpdateSchema(DatabaseStatus status)
        {
            try
            {
                ISession session = sessionProvider.OpenSession.Session;

                session.CreateQuery("from ContentItem").SetMaxResults(1).List();
                session.CreateQuery("from ContentDetail").SetMaxResults(1).List();
                session.CreateQuery("from AuthorizedRole").SetMaxResults(1).List();
                session.CreateQuery("from DetailCollection").SetMaxResults(1).List();
                //session.CreateQuery("from ContentVersion").SetMaxResults(1).List();

                status.HasSchema = true;

                return true;
            }
            catch (Exception ex)
            {
                logger.Error(ex);
                status.HasSchema = false;
                status.SchemaError = ex.Message;
                status.SchemaException = ex;

                return false;
            }
        }

        public static void UpdateRecordedValues(DatabaseStatus status)
        {
            try
            {
                if (status.RootItem == null)
                    return;

                status.AppPath = status.RootItem[InstallationAppPath] as string;
                status.NeedsRebase = !string.IsNullOrEmpty(status.AppPath) && !string.Equals(status.AppPath, N2.Web.Url.ToAbsolute("~/"));

                Version v;
                if (status.RootItem[installationAssemblyVersion] != null && Version.TryParse(status.RootItem[installationAssemblyVersion].ToString(), out v))
                    status.RecordedAssemblyVersion = v;
                if (status.RootItem[installationFileVersion] != null && Version.TryParse(status.RootItem[installationFileVersion].ToString(), out v))
                    status.RecordedFileVersion = v;

                status.RecordedFeatures = status.RootItem.GetInstalledFeatures();

                status.RecordedImageSizes = status.RootItem.GetInstalledImageSizes().ToArray();
            }
            catch (Exception ex)
            {
                status.ItemsError = ex.Message;
            }
        }

        public override MigrationResult Migrate(DatabaseStatus preSchemaUpdateStatus)
        {
            preSchemaUpdateStatus.RootItem[InstallationManager.InstallationAppPath] = N2.Web.Url.ToAbsolute("~/");
            repository.Update(preSchemaUpdateStatus.RootItem);
            repository.Flush();

            return new MigrationResult(this) { UpdatedItems = 1 };
        }

		protected void UpdateConnection(DatabaseStatus status)
		{
			//base.UpdateConnection(status);
			if (GetConnectionException() == null)
			{
				status.IsConnected = true;
			}
		}

		public override bool IsApplicable(DatabaseStatus status)
		{
			if (!status.IsInstalled)
				return false;

			var recordedSizeHash = string.Join(";", status.RecordedImageSizes.OrderBy(s => s.Name).Select(s => s.ToString()));
			var existingSizeHash = string.Join(";", configuredSizes.AllElements.OrderBy(s => s.Name).Select(s => s.ToString()));

			return recordedSizeHash != existingSizeHash;
		}

 public virtual IEnumerable<MigrationResult> MigrateOnly(DatabaseStatus initialStatus)
 {
     List<MigrationResult> results = new List<MigrationResult>();
     foreach (var service in GetMigrations(initialStatus))
     {
         var result = service.Migrate(initialStatus);
         results.Add(result);
     }
     return results;
 }

        public override MigrationResult Migrate(DatabaseStatus preSchemaUpdateStatus)
        {
            var root = persister.Get(preSchemaUpdateStatus.RootItemID);
            root[InstallationManager.installationAssemblyVersion] = typeof(Context).Assembly.GetName().Version.ToString();
            root[InstallationManager.installationFileVersion] = InstallationUtility.GetFileVersion(typeof(Context).Assembly);
            root.RecordInstalledFeature("CMS");

            persister.Save(root);
            return new MigrationResult(this) { UpdatedItems = 1 };
        }

		public bool? TryApplicable(DatabaseStatus initialStatus)
		{
			try
			{
				return IsApplicable(initialStatus);
			}
			catch (System.Exception)
			{
				return null;
			}
		}

        public override bool IsApplicable(DatabaseStatus status)
        {
            try
            {
	            return persister.Repository.Count(new Parameter("class", "News")) > 0;
            }
            catch (Exception)
            {
                return true;
            }
        }

 public override bool IsApplicable(DatabaseStatus status)
 {
     try
     {
         return persister.Repository.Find(new Parameter("class", "Redirect")).Where(p => p.Parent is Models.Pages.LanguageRoot).Any();
     }
     catch (Exception)
     {
         return true;
     }
 }

        public override string CheckConnection(out string stackTrace)
        {
            stackTrace = null;

            var status = new DatabaseStatus();
            if (UpdateConnection(status))
                return null;

            stackTrace = status.ConnectionException.StackTrace;
            return status.ConnectionError;
        }

 public override bool IsApplicable(DatabaseStatus status)
 {
     try
     {
         return status.RootItem != null && status.RootItem["RecordedAssemblyVersion"] == null;
     }
     catch (Exception)
     {
         return false;
     }
 }

 public override bool IsApplicable(DatabaseStatus status)
 {
     try
     {
         return GetNews().Any();
     }
     catch (Exception)
     {
         return true;
     }
 }

 public override bool IsApplicable(DatabaseStatus status)
 {
     try
     {
         return persister.Repository.Find(new Parameter("class", "Top")).Where(p => p.State != ContentState.Deleted).Any();
     }
     catch (Exception)
     {
         return true;
     }
 }

		public override MigrationResult Migrate(DatabaseStatus preSchemaUpdateStatus)
		{
			var path = config.UploadFolders.AllElements.Where(uf => !string.IsNullOrEmpty(uf.UrlPrefix)).Select(uf => uf.Path).FirstOrDefault();
			path = Url.ToAbsolute(path);

			return new MigrationResult(this) 
			{ 
				RedirectTo = "{ManagementUrl}/Content/LinkTracker/UpdateReferences.aspx"
					+ "?selectedUrl=" + path 
					+ "&previousUrl=" +  path
					+ "&location=upgrade"
			};
		}

        public virtual IEnumerable<MigrationResult> MigrateOnly(DatabaseStatus initialStatus)
        {
            List<MigrationResult> results = new List<MigrationResult>();
	        var migs = GetMigrations(initialStatus).ToList();
            for (int i = 0; i < migs.Count; ++i)
            {
	            var service = migs[i];
	            PostProgress(String.Format("Migrating service {0} of {1} ('{2}')", i, migs.Count, service.Title));
                var result = service.Migrate(initialStatus);
                results.Add(result);
            }
            return results;
        }