public void Delete(RecordingDataSet recordingDataSet, long genreId)
 {
     RecordingDataSet.Genre loadedGenre =
         FindById(genreId, recordingDataSet);
     loadedGenre.Delete();
     adapter.Update(recordingDataSet, recordingDataSet.Genres.TableName);
 }
    public override void Insert()
    {
        recordingDataSet = new RecordingDataSet();

        recordingGateway = new RecordingGateway(Connection);
        trackGateway     = new TrackGateway(Connection);
        reviewGateway    = new ReviewGateway(Connection);
        reviewerGateway  = new ReviewerGateway(Connection);
        labelGateway     = new LabelGateway(Connection);
        artistGateway    = new ArtistGateway(Connection);
        genreGateway     = new GenreGateway(Connection);

        artistId    = artistGateway.Insert(recordingDataSet, "Artist");
        labelId     = labelGateway.Insert(recordingDataSet, "Label");
        genreId     = genreGateway.Insert(recordingDataSet, "Genre");
        reviewerId  = reviewerGateway.Insert(recordingDataSet, "Reviewer");
        recordingId = recordingGateway.Insert(recordingDataSet,
                                              "Recording Title", new DateTime(1999, 1, 12), artistId, labelId);
        reviewId = reviewGateway.Insert(recordingDataSet, 1, "Review");
        trackId  = trackGateway.Insert(recordingDataSet, "Track Title", 120);

        RecordingDataSet.Recording recording =
            recordingGateway.FindById(recordingId, recordingDataSet);

        RecordingDataSet.Review review =
            reviewGateway.FindById(reviewId, recordingDataSet);

        RecordingDataSet.Track track =
            trackGateway.FindById(trackId, recordingDataSet);

        RecordingDataSet.Label label =
            labelGateway.FindById(labelId, recordingDataSet);

        RecordingDataSet.Genre genre =
            genreGateway.FindById(genreId, recordingDataSet);

        RecordingDataSet.Artist artist =
            artistGateway.FindById(artistId, recordingDataSet);

        RecordingDataSet.Reviewer reviewer =
            reviewerGateway.FindById(reviewerId, recordingDataSet);

        // setup the relationships
        recording.Artist = artist;
        recording.Label  = label;
        track.Recording  = recording;
        track.Artist     = artist;
        track.Genre      = genre;
        review.Recording = recording;
        review.Reviewer  = reviewer;

        recordingGateway.Update(recordingDataSet);
        trackGateway.Update(recordingDataSet);
        reviewGateway.Update(recordingDataSet);

        RecordingDataSet loadedDataSet = new RecordingDataSet();

        loadedRecording = Catalog.FindByRecordingId(loadedDataSet, recordingId);
    }
        public void RetrieveGenreFromDatabase()
        {
            RecordingDataSet loadedFromDB = new RecordingDataSet();

            RecordingDataSet.Genre loadedGenre =
                gateway.FindById(genreId, loadedFromDB);

            Assert.AreEqual(genreId, loadedGenre.Id);
            Assert.AreEqual(genreName, loadedGenre.Name);
        }
        public void DeleteGenreFromDatabase()
        {
            RecordingDataSet emptyDataSet   = new RecordingDataSet();
            long             deletedGenreId = gateway.Insert(emptyDataSet, "Deleted Genre");

            gateway.Delete(emptyDataSet, deletedGenreId);

            RecordingDataSet.Genre deletedGenre =
                gateway.FindById(deletedGenreId, emptyDataSet);
            Assert.IsNull(deletedGenre);
        }
        public void UpdateGenreInDatabase()
        {
            RecordingDataSet.Genre genre = recordingDataSet.Genres[0];
            genre.Name = "Modified Name";
            gateway.Update(recordingDataSet);

            RecordingDataSet updatedDataSet = new RecordingDataSet();

            RecordingDataSet.Genre updatedGenre =
                gateway.FindById(genreId, updatedDataSet);
            Assert.AreEqual("Modified Name", updatedGenre.Name);
        }
            public void Execute()
            {
                SqlConnection connection =
                    TransactionManager.Transaction().Connection;
                RecordingGateway recordingGateway =
                    new RecordingGateway(connection);

                recording = recordingGateway.FindById(recordingId, dataSet);

                if (recording == null)
                {
                    return;
                }
                long          artistId      = recording.ArtistId;
                ArtistGateway artistGateway = new ArtistGateway(connection);

                RecordingDataSet.Artist artist =
                    artistGateway.FindById(artistId, dataSet);

                long         labelId      = recording.LabelId;
                LabelGateway labelGateway = new LabelGateway(connection);

                RecordingDataSet.Label label =
                    labelGateway.FindById(labelId, dataSet);

                GenreGateway genreGateway = new GenreGateway(connection);

                TrackGateway trackGateway = new TrackGateway(connection);

                foreach (RecordingDataSet.Track track in
                         trackGateway.FindByRecordingId(recordingId, dataSet))
                {
                    artistId = track.ArtistId;
                    long genreId = track.GenreId;
                    artist = artistGateway.FindById(artistId, dataSet);
                    RecordingDataSet.Genre genre =
                        genreGateway.FindById(genreId, dataSet);
                }

                ReviewGateway   reviewGateway   = new ReviewGateway(connection);
                ReviewerGateway reviewerGateway = new ReviewerGateway(connection);

                foreach (RecordingDataSet.Review review in
                         reviewGateway.FindByRecordingId(recordingId, dataSet))
                {
                    long reviewerId = review.ReviewerId;

                    RecordingDataSet.Reviewer reviewer =
                        reviewerGateway.FindById(reviewerId, dataSet);
                }
            }
        public long Insert(RecordingDataSet recordingDataSet, string genreName)
        {
            long genreId =
                IdGenerator.GetNextId(recordingDataSet.Genres.TableName,
                                      connection);

            RecordingDataSet.Genre genreRow =
                recordingDataSet.Genres.NewGenre();
            genreRow.Id   = genreId;
            genreRow.Name = genreName;
            recordingDataSet.Genres.AddGenre(genreRow);

            adapter.Update(recordingDataSet, recordingDataSet.Genres.TableName);

            return(genreId);
        }
    public void SetUp()
    {
        RecordingDataSet recordingDataSet = new RecordingDataSet();

        artist      = recordingDataSet.Artists.NewArtist();
        artist.Id   = 1;
        artist.Name = "Artist";
        recordingDataSet.Artists.AddArtist(artist);

        genre      = recordingDataSet.Genres.NewGenre();
        genre.Id   = 1;
        genre.Name = "Genre";
        recordingDataSet.Genres.AddGenre(genre);

        track          = recordingDataSet.Tracks.NewTrack();
        track.Id       = 1;
        track.Title    = "Track Title";
        track.Duration = 100;
        track.Genre    = genre;
        track.Artist   = artist;
        recordingDataSet.Tracks.AddTrack(track);

        trackDto = RecordingAssembler.WriteTrack(track);
    }
        public void SetUp()
        {
            RecordingDataSet recordingDataSet = new RecordingDataSet();

            artist = recordingDataSet.Artists.NewArtist();
            artist.Id = 1;
            artist.Name = "Artist";
            recordingDataSet.Artists.AddArtist(artist);

            genre = recordingDataSet.Genres.NewGenre();
            genre.Id = 1;
            genre.Name = "Genre";
            recordingDataSet.Genres.AddGenre(genre);

            track = recordingDataSet.Tracks.NewTrack();
            track.Id = 1;
            track.Title = "Track Title";
            track.Duration = 100;
            track.Genre = genre;
            track.Artist = artist;
            recordingDataSet.Tracks.AddTrack(track);

            trackDto = RecordingAssembler.WriteTrack(track);
        }
Esempio n. 10
0
        public static RecordingDataSet.Recording FindByRecordingId(
            RecordingDataSet recordingDataSet, long recordingId)
        {
            SqlConnection connection = null;

            RecordingDataSet.Recording recording = null;

            try
            {
                connection = new SqlConnection(
                    ConfigurationSettings.AppSettings.Get("Catalog.Connection"));
                connection.Open();

                RecordingGateway recordingGateway = new RecordingGateway(connection);
                recording = recordingGateway.FindById(recordingId, recordingDataSet);
                if (recording != null)
                {
                    long                    artistId      = recording.ArtistId;
                    ArtistGateway           artistGateway = new ArtistGateway(connection);
                    RecordingDataSet.Artist artist        =
                        artistGateway.FindById(artistId, recordingDataSet);

                    long                   labelId      = recording.LabelId;
                    LabelGateway           labelGateway = new LabelGateway(connection);
                    RecordingDataSet.Label label        =
                        labelGateway.FindById(labelId, recordingDataSet);

                    GenreGateway genreGateway = new GenreGateway(connection);
                    TrackGateway trackGateway = new TrackGateway(connection);
                    foreach (RecordingDataSet.Track track in
                             trackGateway.FindByRecordingId(recordingId, recordingDataSet))
                    {
                        artistId = track.ArtistId;
                        long genreId = track.GenreId;
                        artist = artistGateway.FindById(artistId, recordingDataSet);
                        RecordingDataSet.Genre genre =
                            genreGateway.FindById(genreId, recordingDataSet);
                    }

                    ReviewGateway   reviewGateway   = new ReviewGateway(connection);
                    ReviewerGateway reviewerGateway = new ReviewerGateway(connection);
                    foreach (RecordingDataSet.Review review in
                             reviewGateway.FindByRecordingId(recordingId, recordingDataSet))
                    {
                        long reviewerId = review.ReviewerId;

                        RecordingDataSet.Reviewer reviewer =
                            reviewerGateway.FindById(reviewerId, recordingDataSet);
                    }
                }
            }
            finally
            {
                if (connection != null)
                {
                    connection.Close();
                }
            }

            return(recording);
        }
 public void GenreOfTheTrack()
 {
     RecordingDataSet.Genre loadedGenre = loadedRecording.GetTracks()[0].Genre;
     Assert.AreEqual(genreId, loadedGenre.Id);
 }
Esempio n. 12
0
    public static RecordingDataSet.Recording Make()
    {
        RecordingDataSet dataSet = new RecordingDataSet();

        RecordingDataSet.Recording recording =
            dataSet.Recordings.NewRecording();
        recording.Id          = 1;
        recording.Title       = "Title";
        recording.ReleaseDate = DateTime.Today;

        RecordingDataSet.Label label = dataSet.Labels.NewLabel();
        label.Id   = 1;
        label.Name = "Label";
        dataSet.Labels.AddLabel(label);

        RecordingDataSet.Artist artist = dataSet.Artists.NewArtist();
        artist.Id   = 1;
        artist.Name = "Artist";
        dataSet.Artists.AddArtist(artist);

        recording.Label  = label;
        recording.Artist = artist;
        dataSet.Recordings.AddRecording(recording);

        RecordingDataSet.Genre genre = dataSet.Genres.NewGenre();
        genre.Id   = 1;
        genre.Name = "Genre";
        dataSet.Genres.AddGenre(genre);

        int       trackCount = 2;
        ArrayList tracks     = new ArrayList(trackCount);

        for (int i = 0; i < trackCount; i++)
        {
            RecordingDataSet.Track track = dataSet.Tracks.NewTrack();
            track.Recording = recording;
            track.Id        = i + 1;
            track.Title     = "Track Title";
            track.Duration  = 100;
            track.Genre     = genre;
            track.Artist    = artist;
            dataSet.Tracks.AddTrack(track);
            tracks.Add(track);
        }

        RecordingDataSet.Reviewer reviewer =
            dataSet.Reviewers.NewReviewer();
        reviewer.Id   = 1;
        reviewer.Name = "Reviewer";
        dataSet.Reviewers.AddReviewer(reviewer);

        int       reviewCount = 3;
        ArrayList reviews     = new ArrayList(reviewCount);

        for (int j = 0; j < reviewCount; j++)
        {
            RecordingDataSet.Review review = dataSet.Reviews.NewReview();
            review.Id        = j + 1;
            review.Content   = "Review Content";
            review.Rating    = j + 1;
            review.Reviewer  = reviewer;
            review.Recording = recording;
            dataSet.Reviews.AddReview(review);
            reviews.Add(review);
        }

        return(recording);
    }