public void Delete(RecordingDataSet recordingDataSet, long recordingId)
        {
            RecordingDataSet.Recording loadedRecording = FindById(recordingId, recordingDataSet);
            loadedRecording.Delete();

            adapter.Update(recordingDataSet, recordingDataSet.Recordings.TableName);
        }
Example #2
0
 public void setup_and_open_Connection_pass_to_gateway_setup_the_dataSet()
 {
     recordingDataSet = new RecordingDataSet();
     gateway = new ArtistGateway(Connection);
     // insert a new artist getting its ID from the database
     artistId = gateway.Insert(recordingDataSet, artistName);
 }
Example #3
0
        public void Delete(RecordingDataSet recordingDataSet, long trackId)
        {
            RecordingDataSet.Track loadedTrack = FindById(trackId, recordingDataSet);
            loadedTrack.Delete();

            adapter.Update(recordingDataSet, recordingDataSet.Tracks.TableName);
        }
Example #4
0
 public void RetrieveLabelFromDatabase()
 {
     RecordingDataSet loadedFromDB = new RecordingDataSet();
     RecordingDataSet.Label loadedLabel = gateway.FindById(labelId, loadedFromDB);
     Assert.AreEqual(labelId,loadedLabel.Id);
     Assert.AreEqual(labelName, loadedLabel.Name);
 }
        public RecordingDataSet make_sample_recording_with_artist_id_and_label_id_and_insert_into_database(SqlConnection connection)
        {
            RecordingDataSet recordingDataSet = new RecordingDataSet();

            recordingGateway = new RecordingGateway(connection);
            artistGateway = new ArtistGateway(connection);
            labelGateway = new LabelGateway(connection);

            artistId = artistGateway.Insert(recordingDataSet, "Artist");
            labelId = labelGateway.Insert(recordingDataSet, "Label");
            recordingId = recordingGateway.Insert(recordingDataSet, title, releaseDate, artistId, labelId);

            trackGateway = new TrackGateway(connection);
            trackId = trackGateway.Insert(recordingDataSet, "Track", 120);
            RecordingDataSet.Track inMemoryDataset_table_track = trackGateway.FindById(trackId, recordingDataSet);

               // RecordingDataSet rec = new RecordingDataSet();

               // RecordingDataSet.Recording recording = recordingGateway.FindById(recordingId, rec);
               //// // link the sample_recording to the track we just created
               //inMemoryDataset_table_track.Recording = recording;
               //trackGateway.Update(rec);

               // recordingGateway.FindById(recordingId, recordingDataSet);

            return recordingDataSet;
        }
        public void AverageRatingZero()
        {
            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);

            RecordingDto dto = RecordingAssembler.WriteDto(recording);
            Assert.AreEqual(0, dto.averageRating);
        }
Example #7
0
        public void SetUp()
        {
            recordingDataSet = new RecordingDataSet();

            gateway = new ReviewGateway(Connection);
            reviewId = gateway.Insert(recordingDataSet, rating, content);
        }
Example #8
0
        public void SetUp()
        {
            recordingDataSet = new RecordingDataSet();
            gateway = new TrackGateway(Connection);

            trackId = gateway.Insert(recordingDataSet,title,duration);
        }
Example #9
0
        public void Delete(RecordingDataSet recordingDataSet, long artistId)
        {
            RecordingDataSet.Artist loadedArtist = FindById(artistId, recordingDataSet);

            loadedArtist.Delete();

            adapter.Update(recordingDataSet, recordingDataSet.Artists.TableName);
        }
Example #10
0
 public RecordingDataSet.Track[] FindByRecordingId(
     long recordingId, RecordingDataSet recordingDataSet)
 {
     findByRecordingIdCommand.Parameters["@recordingId"].Value = recordingId;
     findByRecordingIdAdapter.Fill(recordingDataSet, recordingDataSet.Tracks.TableName);
     DataRow[] rows = recordingDataSet.Tracks.Select(String.Format("recordingId={0}", recordingId));
     return (RecordingDataSet.Track[]) rows;
 }
Example #11
0
        public void RetrieveGenreFromDatabase()
        {
            RecordingDataSet loadedFromDB = new RecordingDataSet();
            RecordingDataSet.Genre loadedGenre = gateway.FindById(genreId, loadedFromDB);

            Assert.AreEqual(genreId, loadedGenre.Id);
            Assert.AreEqual(GenreName, loadedGenre.Name);
        }
Example #12
0
        public void RetrieveReviewerFromDatabase()
        {
            RecordingDataSet loadedFromDB = new RecordingDataSet();
            RecordingDataSet.Reviewer loadedReviewer = gateway.FindById(reviewerId, loadedFromDB);

            Assert.AreEqual(reviewerId, loadedReviewer.Id);
            Assert.AreEqual(reviewerName, loadedReviewer.Name);
        }
Example #13
0
        public void RetrieveArtistFromDatabase()
        {
            RecordingDataSet loadedFromDB = new RecordingDataSet();
            RecordingDataSet.Artist loadedArtist =
               gateway.FindById(artistId, loadedFromDB);

            Assert.AreEqual(artistId, loadedArtist.Id);
            Assert.AreEqual(artistName, loadedArtist.Name);
        }
Example #14
0
        public void RetrieveReviewFromDatabase()
        {
            RecordingDataSet loadedFromDB = new RecordingDataSet();
            RecordingDataSet.Review loadedReview = gateway.FindById(reviewId, loadedFromDB);

            Assert.AreEqual(reviewId, loadedReview.Id);
            Assert.AreEqual(rating, loadedReview.Rating);
            Assert.AreEqual(content, loadedReview.Content);
        }
Example #15
0
        public void DeleteTrackFromDatabase()
        {
            RecordingDataSet emptyDataSet = new RecordingDataSet();
            long deletedTrackId = gateway.Insert(emptyDataSet, "Deleted Title", 0);
            gateway.Delete(emptyDataSet, deletedTrackId);

            RecordingDataSet.Track deleletedTrack = gateway.FindById(deletedTrackId, emptyDataSet);
            Assert.IsNull(deleletedTrack);
        }
Example #16
0
       public void Delete(RecordingDataSet recordingDataSet,
 long genreId)
       {
           RecordingDataSet.Genre loadedGenre =
              FindById(genreId, recordingDataSet);
           loadedGenre.Delete();
           adapter.Update(recordingDataSet,
              recordingDataSet.Genres.TableName);
       }
Example #17
0
        public RecordingDataSet.Artist FindById(long artistId, RecordingDataSet recordingDataSet)
        {
            command.Parameters["@id"].Value = artistId;
            adapter.Fill(recordingDataSet, recordingDataSet.Artists.TableName);
            DataRow[] rows = recordingDataSet.Artists.Select(String.Format("id={0}", artistId));

            if (rows.Length < 1) return null;
            return (RecordingDataSet.Artist) rows[0];
        }
Example #18
0
        public void RetrieveTrackFromDatabase()
        {
            RecordingDataSet loadedFromDB = new RecordingDataSet();
            RecordingDataSet.Track loadedTrack = gateway.FindById(trackId, loadedFromDB);

            Assert.AreEqual(trackId, loadedTrack.Id);
            Assert.AreEqual(title, loadedTrack.Title);
            Assert.AreEqual(duration, loadedTrack.Duration);
        }
Example #19
0
        public void DeleteReviewFromDatabase()
        {
            RecordingDataSet emptyDataSet = new RecordingDataSet();
            long deletedReviewId = gateway.Insert(emptyDataSet, 1, "Deleted Review");
            gateway.Delete(emptyDataSet, deletedReviewId);

            RecordingDataSet.Review deleletedReview = gateway.FindById(deletedReviewId, emptyDataSet);
            Assert.IsNull(deleletedReview);
        }
 static void WriteReviews(RecordingDto recordingDto, RecordingDataSet.Recording recording)
 {
     recordingDto.reviews = new ReviewDto[recording.GetReviews().Length];
     int index = 0;
     foreach (RecordingDataSet.Review review in recording.GetReviews())
     {
         recordingDto.reviews[index++] = WriteReview(review);
     }
 }
Example #21
0
        public void DeleteLabelFromDatabase()
        {
            RecordingDataSet emptyDataSet = new RecordingDataSet();
            long deletedLabelId = gateway.Insert(emptyDataSet,"Deleted Label");
            gateway.Delete(emptyDataSet,deletedLabelId);

            RecordingDataSet.Label deleletedLabel = gateway.FindById(deletedLabelId, emptyDataSet);
            Assert.IsNull(deleletedLabel);
        }
Example #22
0
        public void UpdateArtistAlreadyInTheDatabase_testing_Update()
        {
            RecordingDataSet.Artist artist = recordingDataSet.Artists[0];
            artist.Name = "Modified Name";
            gateway.Update(recordingDataSet);

            RecordingDataSet updatedDataSet = new RecordingDataSet();
            RecordingDataSet.Artist updatedArtist = gateway.FindById(artistId, updatedDataSet);
            Assert.AreEqual("Modified Name", updatedArtist.Name);
        }
 // Intelligent mappings..may be better somewhere else?
 public static void WriteTotalRuntime(RecordingDto dto, RecordingDataSet.Recording recording)
 {
     int runTime = 0;
     foreach (RecordingDataSet.Track track in recording.GetTracks())
     {
         runTime += track.Duration;
     }
     dto.totalRunTimeSpecified = true;
     dto.totalRunTime = runTime;
 }
Example #24
0
        public RecordingDataSet.Track FindById(long trackId, RecordingDataSet recordingDataSet)
        {
            command.Parameters["@id"].Value = trackId;
            adapter.Fill(recordingDataSet, recordingDataSet.Tracks.TableName);
            DataRow[] rows = recordingDataSet.Tracks.Select(String.Format("id={0}", trackId));
            if (rows.Length < 1) return null;

            RecordingDataSet.Track track = (RecordingDataSet.Track) rows[0];
            return track;
        }
Example #25
0
        public RecordingDataSet.Review FindById(long reviewId, RecordingDataSet recordingDataSet)
        {
            reviewCommand.Parameters["@id"].Value = reviewId;
            reviewAdapter.Fill(recordingDataSet, recordingDataSet.Reviews.TableName);
            DataRow[] rows = recordingDataSet.Reviews.Select(String.Format("id={0}", reviewId));
            if (rows.Length < 1) return null;

            RecordingDataSet.Review review = (RecordingDataSet.Review) rows[0];
            return review;
        }
Example #26
0
        public void SetUp()
        {
            connection = new SqlConnection(ConfigurationSettings.AppSettings.Get("Catalog.Connection"));
            connection.Open();

            recordingDataSet = new RecordingDataSet();
            gateway = new GenreGateway(connection);

            genreId = gateway.Insert(recordingDataSet, genreName);
        }
Example #27
0
        public RecordingDataSet.Label FindById(long labelId, RecordingDataSet recordingDataSet)
        {
            command.Parameters["@id"].Value = labelId;
            adapter.Fill(recordingDataSet, recordingDataSet.Labels.TableName);
            DataRow[] rows = recordingDataSet.Labels.Select(String.Format("id={0}", labelId));
            if (rows.Length < 1) return null;

            RecordingDataSet.Label label = (RecordingDataSet.Label)rows[0];
            return label;
        }
Example #28
0
        public void RetrieveArtistFromDatabase_testing_FindById()
        {
            // create another RecordingDataSet, use same gateway.
            RecordingDataSet loadedFromDB = new RecordingDataSet();

            RecordingDataSet.Artist loadedArtist = gateway.FindById(artistId, loadedFromDB);

            Assert.AreEqual(artistId, loadedArtist.Id);
            Assert.AreEqual(artistName, loadedArtist.Name);
        }
Example #29
0
        public void UpdateArtistAlreadyInTheDatabase()
        {
            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);
        }
Example #30
0
        public void UpdateLableNameInDatabase()
        {
            RecordingDataSet.Label label = recordingDataSet.Labels[0];
            label.Name = "Modified Name";
            gateway.Update(recordingDataSet);

            RecordingDataSet updatedDataSet = new RecordingDataSet();
            RecordingDataSet.Label updatedLabel = gateway.FindById(labelId, updatedDataSet);
            Assert.AreEqual("Modified Name", updatedLabel.Name);
        }
        FindById(long genreId, RecordingDataSet recordingDataSet)
        {
            command.Parameters["@id"].Value = genreId;
            adapter.Fill(recordingDataSet, recordingDataSet.Genres.TableName);
            DataRow[] rows = recordingDataSet.Genres.Select(
                String.Format("id={0}", genreId));

            if (rows.Length < 1)
            {
                return(null);
            }
            return((RecordingDataSet.Genre)rows[0]);
        }
Example #32
0
        public void CheckDelete()
        {
            RecordingDataSet emptyDataSet = new RecordingDataSet();

            long deletedRecordingId = recordingGateway.Insert(emptyDataSet,
                                                              "Deleted Title", new DateTime(1991, 8, 6), Builder.ArtistId, Builder.LabelId);

            recordingGateway.Delete(emptyDataSet, deletedRecordingId);

            RecordingDataSet.Recording deleletedRecording =
                recordingGateway.FindById(deletedRecordingId, emptyDataSet);
            Assert.IsNull(deleletedRecording);
        }
        public void UpdateReviewFieldInReview()
        {
            string modifiedContent = "Modified Content";

            RecordingDataSet.Review review = recordingDataSet.Reviews[0];
            review.Content = modifiedContent;
            gateway.Update(recordingDataSet);

            RecordingDataSet updatedDataSet = new RecordingDataSet();

            RecordingDataSet.Review updatedReview = gateway.FindById(reviewId, updatedDataSet);
            Assert.AreEqual(modifiedContent, updatedReview.Content);
        }
Example #34
0
    public void AddReviewWithoutExistingReviewer()
    {
        int    rating  = 1;
        string content = "Review content";

        RecordingDataSet.Review review = Catalog.AddReview(recordingDataSet, reviewerName, content, rating, recordingId);
        Assert.IsNotNull(review);

        RecordingDataSet loadedFromDBDataSet = new RecordingDataSet();

        RecordingDataSet.Recording loadedFromDBRecording = Catalog.FindByRecordingId(loadedFromDBDataSet, recordingId);
        Assert.AreEqual(1, loadedFromDBRecording.GetReviews().Length);
    }
        public void UpdateTitleFieldInTrack()
        {
            string modifiedTitle = "Modified Title";

            RecordingDataSet.Track track = recordingDataSet.Tracks[0];
            track.Title = modifiedTitle;
            gateway.Update(recordingDataSet);

            RecordingDataSet updatedDataSet = new RecordingDataSet();

            RecordingDataSet.Track updatedTrack = gateway.FindById(trackId, updatedDataSet);
            Assert.AreEqual(modifiedTitle, updatedTrack.Title);
        }
Example #36
0
        public RecordingDataSet.Label FindById(long labelId, RecordingDataSet recordingDataSet)
        {
            command.Parameters["@id"].Value = labelId;
            adapter.Fill(recordingDataSet, recordingDataSet.Labels.TableName);
            DataRow[] rows = recordingDataSet.Labels.Select(String.Format("id={0}", labelId));
            if (rows.Length < 1)
            {
                return(null);
            }

            RecordingDataSet.Label label = (RecordingDataSet.Label)rows[0];
            return(label);
        }
        public void UpdateDurationFieldInTrack()
        {
            int modifiedDuration = 300;

            RecordingDataSet.Track track = recordingDataSet.Tracks[0];
            track.Duration = modifiedDuration;
            gateway.Update(recordingDataSet);

            RecordingDataSet updatedDataSet = new RecordingDataSet();

            RecordingDataSet.Track updatedTrack = gateway.FindById(trackId, updatedDataSet);
            Assert.AreEqual(modifiedDuration, updatedTrack.Duration);
        }
        public RecordingDataSet.Reviewer FindById(long reviewerId, RecordingDataSet recordingDataSet)
        {
            command.Parameters["@id"].Value = reviewerId;
            adapter.Fill(recordingDataSet, recordingDataSet.Reviewers.TableName);
            DataRow[] rows = recordingDataSet.Reviewers.Select(String.Format("id={0}", reviewerId));
            if (rows.Length < 1)
            {
                return(null);
            }

            RecordingDataSet.Reviewer reviewer = (RecordingDataSet.Reviewer)rows[0];
            return(reviewer);
        }
        public long Insert(RecordingDataSet recordingDataSet, string reviewerName)
        {
            long reviewerId = IdGenerator.GetNextId(recordingDataSet.Reviewers.TableName, connection);

            RecordingDataSet.Reviewer reviewerRow = recordingDataSet.Reviewers.NewReviewer();
            reviewerRow.Id   = reviewerId;
            reviewerRow.Name = reviewerName;
            recordingDataSet.Reviewers.AddReviewer(reviewerRow);

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

            return(reviewerId);
        }
    public RecordingDataSet.Track FindById(long trackId, RecordingDataSet recordingDataSet)
    {
        command.Parameters["@id"].Value = trackId;
        adapter.Fill(recordingDataSet, recordingDataSet.Tracks.TableName);
        DataRow[] rows = recordingDataSet.Tracks.Select(String.Format("id={0}", trackId));
        if (rows.Length < 1)
        {
            return(null);
        }

        RecordingDataSet.Track track = (RecordingDataSet.Track)rows[0];
        return(track);
    }
Example #41
0
        public void RetrieveRecordingFromDatabase()
        {
            RecordingDataSet loadedFromDB = new RecordingDataSet();

            RecordingDataSet.Recording loadedRecording =
                recordingGateway.FindById(Builder.RecordingId, loadedFromDB);

            Assert.AreEqual(Builder.RecordingId, loadedRecording.Id);
            Assert.AreEqual(Builder.Title, loadedRecording.Title);
            Assert.AreEqual(Builder.ReleaseDate, loadedRecording.ReleaseDate);
            Assert.AreEqual(Builder.ArtistId, loadedRecording.ArtistId);
            Assert.AreEqual(Builder.LabelId, loadedRecording.LabelId);
        }
Example #42
0
        public long Insert(RecordingDataSet recordingDataSet, string labelName)
        {
            long labelId = IdGenerator.GetNextId(recordingDataSet.Labels.TableName, connection);

            RecordingDataSet.Label labelRow = recordingDataSet.Labels.NewLabel();
            labelRow.Id   = labelId;
            labelRow.Name = labelName;
            recordingDataSet.Labels.AddLabel(labelRow);

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

            return(labelId);
        }
        public void UpdateRatingFieldInReview()
        {
            int modifiedRating = 2;

            RecordingDataSet.Review review = recordingDataSet.Reviews[0];
            review.Rating = modifiedRating;
            gateway.Update(recordingDataSet);

            RecordingDataSet updatedDataSet = new RecordingDataSet();

            RecordingDataSet.Review updatedReview = gateway.FindById(reviewId, updatedDataSet);
            Assert.AreEqual(modifiedRating, updatedReview.Rating);
        }
        public void UpdateTitleFieldInRecording()
        {
            string modifiedTitle = "Modified Title";

            RecordingDataSet.Recording recording = Recording;
            recording.Title = modifiedTitle;
            recordingGateway.Update(RecordingDataSet);

            RecordingDataSet updatedDataSet = new RecordingDataSet();

            RecordingDataSet.Recording updatedRecording =
                recordingGateway.FindById(Builder.RecordingId, updatedDataSet);
            Assert.AreEqual(modifiedTitle, updatedRecording.Title);
        }
        public void UpdateReviewerFieldInReviewer()
        {
            string modifiedName = "Modified Name";

            RecordingDataSet.Reviewer reviewer = recordingDataSet.Reviewers[0];
            reviewer.Name = modifiedName;
            gateway.Update(recordingDataSet);

            RecordingDataSet updatedDataSet = new RecordingDataSet();

            RecordingDataSet.Reviewer updatedReviewer =
                gateway.FindById(reviewerId, updatedDataSet);
            Assert.AreEqual(modifiedName, updatedReviewer.Name);
        }
        public void UpdateReleaseDateFieldInRecording()
        {
            DateTime modifiedDate = new DateTime(1989, 5, 15);

            RecordingDataSet.Recording recording = Recording;
            recording.ReleaseDate = modifiedDate;
            recordingGateway.Update(RecordingDataSet);

            RecordingDataSet updatedDataSet = new RecordingDataSet();

            RecordingDataSet.Recording updatedRecording =
                recordingGateway.FindById(Builder.RecordingId, updatedDataSet);
            Assert.AreEqual(modifiedDate, updatedRecording.ReleaseDate);
        }
        public RecordingDto FindByRecordingId(long id)
        {
            RecordingDataSet dataSet = new RecordingDataSet();

            RecordingDataSet.Recording recording =
                Catalog.FindByRecordingId(dataSet, id);

            if (recording == null)
            {
                return(null);
            }

            return(RecordingAssembler.WriteDto(recording));
        }
        public void Create()
        {
            recordingDataSet = new RecordingDataSet();

            genreGateway = new GenreGateway(Connection);
            genreId      = genreGateway.Insert(recordingDataSet, "Genre");

            trackGateway = new TrackGateway(Connection);
            trackId      = trackGateway.Insert(recordingDataSet, "Title", 120);

            track = trackGateway.FindById(trackId, recordingDataSet);

            track.GenreId = genreId;
            trackGateway.Update(recordingDataSet);
        }
Example #49
0
        public void Create()
        {
            recordingDataSet = new RecordingDataSet();

            artistGateway = new ArtistGateway(Connection);
            artistId      = artistGateway.Insert(recordingDataSet, "Artist");

            trackGateway = new TrackGateway(Connection);
            trackId      = trackGateway.Insert(recordingDataSet, "Title", 120);

            track = trackGateway.FindById(trackId, recordingDataSet);

            track.ArtistId = artistId;
            trackGateway.Update(recordingDataSet);
        }
    public long Insert(RecordingDataSet recordingDataSet, string title, int duration)
    {
        long trackId = IdGenerator.GetNextId(recordingDataSet.Tracks.TableName, connection);

        RecordingDataSet.Track trackRow = recordingDataSet.Tracks.NewTrack();

        trackRow.Id       = trackId;
        trackRow.Title    = title;
        trackRow.Duration = duration;

        recordingDataSet.Tracks.AddTrack(trackRow);

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

        return(trackId);
    }
        public long Insert(RecordingDataSet recordingDataSet, string artistName)
        {
            long artistId =
                IdGenerator.GetNextId(recordingDataSet.Artists.TableName,
                                      connection);

            RecordingDataSet.Artist artistRow =
                recordingDataSet.Artists.NewArtist();
            artistRow.Id   = artistId;
            artistRow.Name = artistName;
            recordingDataSet.Artists.AddArtist(artistRow);

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

            return(artistId);
        }
        public long Insert(RecordingDataSet recordingDataSet, int rating, string content)
        {
            long reviewId = IdGenerator.GetNextId(recordingDataSet.Reviews.TableName, connection);

            RecordingDataSet.Review reviewRow = recordingDataSet.Reviews.NewReview();

            reviewRow.Id      = reviewId;
            reviewRow.Rating  = rating;
            reviewRow.Content = content;

            recordingDataSet.Reviews.AddReview(reviewRow);

            reviewAdapter.Update(recordingDataSet, recordingDataSet.Reviews.TableName);

            return(reviewId);
        }
        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);
        }
Example #54
0
        public static RecordingDataSet.Review AddReview(RecordingDataSet dataSet,
                                                        string name, string content, int rating, long recordingId)
        {
            SqlConnection connection = null;

            RecordingDataSet.Review review = null;

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

                RecordingDataSet.Recording recording =
                    FindByRecordingId(dataSet, recordingId);

                ReviewerGateway reviewerGateway =
                    new ReviewerGateway(connection);

                RecordingDataSet.Reviewer reviewer =
                    reviewerGateway.FindByName(name, dataSet);

                if (reviewer == null)
                {
                    long reviewerId = reviewerGateway.Insert(dataSet, name);
                    reviewer = reviewerGateway.FindById(reviewerId, dataSet);
                }

                ReviewGateway reviewGateway = new ReviewGateway(connection);
                long          reviewId      = reviewGateway.Insert(dataSet, rating, content);

                review            = reviewGateway.FindById(reviewId, dataSet);
                review.ReviewerId = reviewer.Id;
                review.Recording  = recording;
                reviewGateway.Update(dataSet);
            }
            finally
            {
                if (connection != null)
                {
                    connection.Close();
                }
            }

            return(review);
        }
Example #55
0
    public RecordingDataSet Make(SqlConnection connection)
    {
        RecordingDataSet recordingDataSet = new RecordingDataSet();

        recordingGateway = new RecordingGateway(connection);
        artistGateway    = new ArtistGateway(connection);
        labelGateway     = new LabelGateway(connection);

        artistId    = artistGateway.Insert(recordingDataSet, "Artist");
        labelId     = labelGateway.Insert(recordingDataSet, "Label");
        recordingId = recordingGateway.Insert(recordingDataSet, title,
                                              releaseDate, artistId, labelId);

        recordingGateway.FindById(recordingId, recordingDataSet);

        return(recordingDataSet);
    }
Example #56
0
        public long Insert(RecordingDataSet recordingDataSet, string title, DateTime releaseDate, long artistId, long labelId)
        {
            long recordingId = IdGenerator.GetNextId(recordingDataSet.Recordings.TableName, connection);

            RecordingDataSet.Recording recordingRow = recordingDataSet.Recordings.NewRecording();

            recordingRow.Id          = recordingId;
            recordingRow.Title       = title;
            recordingRow.ReleaseDate = releaseDate;
            recordingRow.ArtistId    = artistId;
            recordingRow.LabelId     = labelId;

            recordingDataSet.Recordings.AddRecording(recordingRow);

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

            return(recordingId);
        }
Example #57
0
        public void MakeReview()
        {
            RecordingDataSet recordingDataSet = new RecordingDataSet();

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

            review          = recordingDataSet.Reviews.NewReview();
            review.Id       = 1;
            review.Content  = "Review Content";
            review.Rating   = 2;
            review.Reviewer = reviewer;
            recordingDataSet.Reviews.AddReview(review);

            reviewDto = RecordingAssembler.WriteReview(review);
        }
Example #58
0
    public void AddTwoReviewsWithExistingReviewer()
    {
        int    rating  = 1;
        string content = "Review content";

        ReviewerGateway reviewerGateway =
            new ReviewerGateway(Connection);
        long reviewerId =
            reviewerGateway.Insert(recordingDataSet, reviewerName);

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

        RecordingDataSet.Review reviewOne =
            Catalog.AddReview(recordingDataSet, reviewerName,
                              content, rating, Recording.Id);

        try
        {
            RecordingDataSet.Review reviewTwo =
                Catalog.AddReview(recordingDataSet,
                                  reviewerName, content, rating, Recording.Id);
            Assert.Fail("Expected an ExistingReviewException");
        }
        catch (ExistingReviewException exception)
        {
            Assert.AreEqual(reviewOne.Id, exception.ExistingId);
        }
        finally
        {
            RecordingDataSet           dbDataSet   = new RecordingDataSet();
            RecordingDataSet.Recording dbRecording =
                Catalog.FindByRecordingId(dbDataSet, Recording.Id);
            RecordingDataSet.Review[] reviews =
                dbRecording.GetReviews();

            ReviewGateway reviewGateway = new ReviewGateway(Connection);
            foreach (RecordingDataSet.Review existingReview in reviews)
            {
                reviewGateway.Delete(dbDataSet, existingReview.Id);
            }
            reviewerGateway.Delete(recordingDataSet, reviewerId);
        }
    }
    public void DeleteReview()
    {
        int    rating  = 1;
        string content = "Review content";

        ReviewerGateway reviewerGateway =
            new ReviewerGateway(Connection);
        long reviewerId = reviewerGateway.Insert(recordingDataSet, reviewerName);

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

        RecordingDataSet.Review review = Catalog.AddReview(recordingDataSet, reviewerName, content, rating, recordingId);
        Catalog.DeleteReview(review.Id);

        RecordingDataSet loadedFromDB = new RecordingDataSet();

        RecordingDataSet.Recording loadedFromDBRecording = Catalog.FindByRecordingId(loadedFromDB, recordingId);
        Assert.AreEqual(0, loadedFromDBRecording.GetReviews().Length);
    }
    public void AddReviewWithExistingReviewer()
    {
        int    rating  = 1;
        string content = "Review content";

        ReviewerGateway reviewerGateway =
            new ReviewerGateway(Connection);
        long reviewerId = reviewerGateway.Insert(recordingDataSet, reviewerName);

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

        RecordingDataSet.Review review = Catalog.AddReview(recordingDataSet, reviewerName, content, rating, recordingId);
        Assert.IsNotNull(review);

        RecordingDataSet loadedFromDBDataSet = new RecordingDataSet();

        RecordingDataSet.Recording loadedFromDBRecording = Catalog.FindByRecordingId(loadedFromDBDataSet, recordingId);
        Assert.AreEqual(1, loadedFromDBRecording.GetReviews().Length);
    }