示例#1
0
        public void TestBackup()
        {
            var directoryInfo = new DirectoryInfo("TestCsv");
            var directoryPath = directoryInfo.FullName;

            try {
                directoryInfo.Refresh();
                if (directoryInfo.Exists)
                {
                    directoryInfo.Delete(recursive: true);
                    directoryInfo.Refresh();
                }

                directoryInfo.Create();
                directoryInfo.Refresh();
                var activeDirectory   = directoryInfo.CreateSubdirectory("Active");
                var backupDirectory   = directoryInfo.CreateSubdirectory("Backup");
                var backupPeriodicity = 2;
                var backupCopies      = 3;
                var csvConfig         = new CsvConfig(activeDirectory.FullName, backupDirectory.FullName, backupPeriodicity, backupCopies);
                var now    = new DateTime(2000, 12, 11);
                var result = Csv.Backup(csvConfig, now);
                Assert.AreEqual(@$ "0 files copied from {directoryPath}\Active 
to {directoryPath}\Backup\csv20001211.", result);

                now    = now.AddDays(1);
                result = Csv.Backup(csvConfig, now);
                Assert.AreEqual(@"Last backup: 11.12.00; Today: 12.12.00; Next backup: 13.12.00;", result);

                File.WriteAllText(activeDirectory.FullName + @"\Data.csv", "some text");
                now    = now.AddDays(1);
                result = Csv.Backup(csvConfig, now);
                Assert.AreEqual(@$ "1 files copied from {directoryPath}\Active 
to {directoryPath}\Backup\csv20001213.", result);

                now    = now.AddDays(1);
                result = Csv.Backup(csvConfig, now);
                Assert.AreEqual(@"Last backup: 13.12.00; Today: 14.12.00; Next backup: 15.12.00;", result);

                File.WriteAllText(activeDirectory.FullName + @"\Data1.csv", "other text");
                now    = now.AddDays(1);
                result = Csv.Backup(csvConfig, now);
                Assert.AreEqual(@$ "2 files copied from {directoryPath}\Active 
to {directoryPath}\Backup\csv20001215.", result);

                File.WriteAllText(activeDirectory.FullName + @"\Data1.csv", "other text");
                now    = now.AddDays(2);
                result = Csv.Backup(csvConfig, now);
                Assert.AreEqual(@$ "2 files copied from {directoryPath}\Active 
to {directoryPath}\Backup\csv20001217.", result);

                File.WriteAllText(activeDirectory.FullName + @"\Data1.csv", "other text");
                now    = now.AddDays(2);
                result = Csv.Backup(csvConfig, now);
                Assert.AreEqual(@$ "Directory {directoryPath}\Backup\csv20001211 deleted
2 files copied from {directoryPath}\Active 
to {directoryPath}\Backup\csv20001219.", result);
            } finally {
                directoryInfo.Delete(recursive: true);
            }
        }
示例#2
0
        public DC(CsvConfig?csvConfig) : base(DataStoresCount: 5)
        {
            data          = this;
            IsInitialised = false;

            string?backupResult = null;

            if (csvConfig != null)
            {
                backupResult = Csv.Backup(csvConfig, DateTime.Now);
            }

            CsvConfig = csvConfig;
            onConstructing(backupResult);

            _LocationsByPathLower = new Dictionary <string, Location>();
            _PlayinglistTracksByPlaylistTrackKey = new Dictionary <int, PlayinglistTrack>();
            _PlaylistsByNameLower = new Dictionary <string, Playlist>();
            _TracksByTitleArtists = new Dictionary <string, Track>();
            if (csvConfig == null)
            {
                _Locations = new DataStore <Location>(
                    this,
                    0,
                    Location.SetKey,
                    Location.RollbackItemNew,
                    Location.RollbackItemStore,
                    Location.RollbackItemUpdate,
                    Location.RollbackItemRelease,
                    areInstancesUpdatable: true,
                    areInstancesReleasable: true);
                DataStores[0] = _Locations;
                onLocationsFilled();

                _Tracks = new DataStore <Track>(
                    this,
                    1,
                    Track.SetKey,
                    Track.RollbackItemNew,
                    Track.RollbackItemStore,
                    Track.RollbackItemUpdate,
                    Track.RollbackItemRelease,
                    areInstancesUpdatable: true,
                    areInstancesReleasable: true);
                DataStores[1] = _Tracks;
                onTracksFilled();

                _Playlists = new DataStore <Playlist>(
                    this,
                    2,
                    Playlist.SetKey,
                    Playlist.RollbackItemNew,
                    Playlist.RollbackItemStore,
                    Playlist.RollbackItemUpdate,
                    Playlist.RollbackItemRelease,
                    areInstancesUpdatable: true,
                    areInstancesReleasable: true);
                DataStores[2] = _Playlists;
                onPlaylistsFilled();

                _PlaylistTracks = new DataStore <PlaylistTrack>(
                    this,
                    3,
                    PlaylistTrack.SetKey,
                    PlaylistTrack.RollbackItemNew,
                    PlaylistTrack.RollbackItemStore,
                    PlaylistTrack.RollbackItemUpdate,
                    PlaylistTrack.RollbackItemRelease,
                    areInstancesUpdatable: true,
                    areInstancesReleasable: true);
                DataStores[3] = _PlaylistTracks;
                onPlaylistTracksFilled();

                _PlayinglistTracks = new DataStore <PlayinglistTrack>(
                    this,
                    4,
                    PlayinglistTrack.SetKey,
                    PlayinglistTrack.RollbackItemNew,
                    PlayinglistTrack.RollbackItemStore,
                    PlayinglistTrack.RollbackItemUpdate,
                    PlayinglistTrack.RollbackItemRelease,
                    areInstancesUpdatable: true,
                    areInstancesReleasable: true);
                DataStores[4] = _PlayinglistTracks;
                onPlayinglistTracksFilled();
            }
            else
            {
                IsPartiallyNew = false;
                _Locations     = new DataStoreCSV <Location>(
                    this,
                    0,
                    csvConfig !,
                    Location.EstimatedLineLength,
                    Location.Headers,
                    Location.SetKey,
                    Location.Create,
                    null,
                    Location.Update,
                    Location.Write,
                    Location.RollbackItemNew,
                    Location.RollbackItemStore,
                    Location.RollbackItemUpdate,
                    Location.RollbackItemRelease,
                    areInstancesUpdatable: true,
                    areInstancesReleasable: true);
                IsPartiallyNew |= _Locations.IsNew;
                IsNew          &= _Locations.IsNew;
                DataStores[0]   = _Locations;
                onLocationsFilled();

                _Tracks = new DataStoreCSV <Track>(
                    this,
                    1,
                    csvConfig !,
                    Track.EstimatedLineLength,
                    Track.Headers,
                    Track.SetKey,
                    Track.Create,
                    Track.Verify,
                    Track.Update,
                    Track.Write,
                    Track.RollbackItemNew,
                    Track.RollbackItemStore,
                    Track.RollbackItemUpdate,
                    Track.RollbackItemRelease,
                    areInstancesUpdatable: true,
                    areInstancesReleasable: true);
                IsPartiallyNew |= _Tracks.IsNew;
                IsNew          &= _Tracks.IsNew;
                DataStores[1]   = _Tracks;
                onTracksFilled();

                _Playlists = new DataStoreCSV <Playlist>(
                    this,
                    2,
                    csvConfig !,
                    Playlist.EstimatedLineLength,
                    Playlist.Headers,
                    Playlist.SetKey,
                    Playlist.Create,
                    null,
                    Playlist.Update,
                    Playlist.Write,
                    Playlist.RollbackItemNew,
                    Playlist.RollbackItemStore,
                    Playlist.RollbackItemUpdate,
                    Playlist.RollbackItemRelease,
                    areInstancesUpdatable: true,
                    areInstancesReleasable: true);
                IsPartiallyNew |= _Playlists.IsNew;
                IsNew          &= _Playlists.IsNew;
                DataStores[2]   = _Playlists;
                onPlaylistsFilled();

                _PlaylistTracks = new DataStoreCSV <PlaylistTrack>(
                    this,
                    3,
                    csvConfig !,
                    PlaylistTrack.EstimatedLineLength,
                    PlaylistTrack.Headers,
                    PlaylistTrack.SetKey,
                    PlaylistTrack.Create,
                    PlaylistTrack.Verify,
                    PlaylistTrack.Update,
                    PlaylistTrack.Write,
                    PlaylistTrack.RollbackItemNew,
                    PlaylistTrack.RollbackItemStore,
                    PlaylistTrack.RollbackItemUpdate,
                    PlaylistTrack.RollbackItemRelease,
                    areInstancesUpdatable: true,
                    areInstancesReleasable: true);
                IsPartiallyNew |= _PlaylistTracks.IsNew;
                IsNew          &= _PlaylistTracks.IsNew;
                DataStores[3]   = _PlaylistTracks;
                onPlaylistTracksFilled();

                _PlayinglistTracks = new DataStoreCSV <PlayinglistTrack>(
                    this,
                    4,
                    csvConfig !,
                    PlayinglistTrack.EstimatedLineLength,
                    PlayinglistTrack.Headers,
                    PlayinglistTrack.SetKey,
                    PlayinglistTrack.Create,
                    null,
                    PlayinglistTrack.Update,
                    PlayinglistTrack.Write,
                    PlayinglistTrack.RollbackItemNew,
                    PlayinglistTrack.RollbackItemStore,
                    PlayinglistTrack.RollbackItemUpdate,
                    PlayinglistTrack.RollbackItemRelease,
                    areInstancesUpdatable: true,
                    areInstancesReleasable: true);
                IsPartiallyNew |= _PlayinglistTracks.IsNew;
                IsNew          &= _PlayinglistTracks.IsNew;
                DataStores[4]   = _PlayinglistTracks;
                onPlayinglistTracksFilled();
            }
            onConstructed();
            IsInitialised = true;
        }