Esempio n. 1
0
        public void SortTest()
        {
            Assert.AreEqual(_albumReview2.Rating,
                            _albumReviewService.ListAlbumReviews(new AlbumReviewFilter {
                SortAscending = true
            }).First().Rating);

            var albumId = 3;
            var album3  = new AlbumDTO
            {
                ID          = albumId,
                InterpretId = _interpret2Id,
                Name        = "Hybrid Theory",
                Year        = 2000
            };

            _albumService.CreateAlbum(album3, _interpret2Id);

            var albumReview = new AlbumReviewDTO
            {
                AlbumId = albumId,
                Note    = "Not bad",
                Rating  = 9,
                ID      = _albumReview2Id
            };

            _albumReviewService.CreateAlbumReview(albumReview, albumId);

            Assert.AreEqual(_albumReview1.Rating,
                            _albumReviewService.ListAlbumReviews(new AlbumReviewFilter {
                SortAscending = false
            }).First().Rating);
        }
 public void CreateAlbumReview(AlbumReviewDTO albumReviewDto, int albumId)
 {
     using (var uow = UnitOfWorkProvider.Create())
     {
         var albumReview = Mapper.Map <AlbumReview>(albumReviewDto);
         albumReview.Album = GetAlbumReviewAlbum(albumId);
         _albumReviewRepository.Insert(albumReview);
         uow.Commit();
     }
 }
 public void EditAlbumReview(AlbumReviewDTO albumReviewDto, int albumId)
 {
     using (var uow = UnitOfWorkProvider.Create())
     {
         var albumReview = _albumReviewRepository.GetById(albumReviewDto.ID);
         Mapper.Map(albumReviewDto, albumReview);
         albumReview.Album = GetAlbumReviewAlbum(albumId);
         _albumReviewRepository.Update(albumReview);
         uow.Commit();
     }
 }
Esempio n. 4
0
        /// <summary>
        /// Adds a review
        /// </summary>
        /// <param name="reviewDTO">Review details</param>
        public void AddReview(AlbumReviewDTO reviewDTO)
        {
            if (reviewDTO == null)
            {
                throw new ArgumentNullException("AlbumReview service - AddReview(...) reviewDTO cannot be null");
            }

            using (var uow = UnitOfWorkProvider.Create())
            {
                var review = Mapper.Map <AlbumReview>(reviewDTO);
                review.Album = GetReviewAlbum(reviewDTO.AlbumID);
                albumReviewRepository.Insert(review);
                uow.Commit();
            }
        }
Esempio n. 5
0
 /// <summary>
 /// Updates review
 /// </summary>
 /// <param name="reviewDTO">Update details</param>
 public void EditAlbumReview(AlbumReviewDTO reviewDTO)
 {
     if (reviewDTO == null)
     {
         throw new ArgumentNullException("Album review service - EditAlbumReview(...) reviewDTO cannot be null");
     }
     using (var uow = UnitOfWorkProvider.Create())
     {
         var review = albumReviewRepository.GetByID(reviewDTO.ID, albumReview => albumReview.Album);
         if (review == null)
         {
             throw new NullReferenceException("Album review service - EditReview(...) the review cannot be null");
         }
         Mapper.Map(reviewDTO, review);
         albumReviewRepository.Update(review);
         uow.Commit();
     }
 }
Esempio n. 6
0
        public void CreateAlbumReview(AlbumReviewDTO albumReviewDTO)
        {
            if (albumReviewDTO == null)
            {
                throw new ArgumentNullException("Album review service - CreateReview(...) review cannot be null");
            }
            using (var uow = UnitOfWorkProvider.Create())
            {
                var albumReview = Mapper.Map <AlbumReviewDTO, AlbumReview>(albumReviewDTO);
                albumReview.Album = GetReviewAlbum(albumReview.Album.ID);

                if (albumReview == null)
                {
                    throw new NullReferenceException("Album review service - CreateReview(...) albumReview cannot be null(could not be found)");
                }

                albumReview.Creator = GetAlbumReviewCreator(albumReviewDTO.CreatorID);

                albumReviewRepository.Insert(albumReview);
                uow.Commit();
            }
        }
 public void EditAlbumReview(AlbumReviewDTO albumReviewDto, int albumId)
 {
     _albumReviewService.EditAlbumReview(albumReviewDto, albumId);
 }
 public void CreateAlbumReview(AlbumReviewDTO albumReviewDto, int albumId)
 {
     _albumReviewService.CreateAlbumReview(albumReviewDto, albumId);
 }
Esempio n. 9
0
        public void Init()
        {
            _interpret1Id = 1;
            _interpret1   = new InterpretDTO
            {
                Name     = "System of a down",
                Language = Language.English,
                ID       = _interpret1Id
            };

            _interpret2Id = 2;
            _interpret2   = new InterpretDTO
            {
                Name     = "Linkin Park",
                Language = Language.English,
                ID       = _interpret2Id
            };

            _interpretService.CreateInterpret(_interpret1);
            _interpretService.CreateInterpret(_interpret2);

            _album1Id = 1;
            _album1   = new AlbumDTO
            {
                ID          = _album1Id,
                InterpretId = _interpret1Id,
                Name        = "Toxicity",
                Year        = 2003
            };

            _album2Id = 2;
            _album2   = new AlbumDTO
            {
                ID          = _album2Id,
                InterpretId = _interpret2Id,
                Name        = "Meteora",
                Year        = 2008
            };

            _albumService.CreateAlbum(_album1, _interpret1Id);
            _albumService.CreateAlbum(_album2, _interpret2Id);

            _albumReview1Id = 1;
            _albumReview1   = new AlbumReviewDTO
            {
                ID      = _albumReview1Id,
                AlbumId = _album1.ID,
                Note    = "Perfect album",
                Rating  = 9
            };

            _albumReview2Id = 2;
            _albumReview2   = new AlbumReviewDTO
            {
                AlbumId = _album2.ID,
                Note    = "Not bad",
                Rating  = 8,
                ID      = _albumReview2Id
            };

            _albumReviewService.CreateAlbumReview(_albumReview1, _album1Id);
            _albumReviewService.CreateAlbumReview(_albumReview2, _album2Id);
        }
Esempio n. 10
0
 public void EditReview(AlbumReviewDTO reviewDTO)
 {
     albumReviewService.EditAlbumReview(reviewDTO);
 }
Esempio n. 11
0
 public void AddReview(AlbumReviewDTO reviewDTO)
 {
     albumReviewService.AddReview(reviewDTO);
 }
Esempio n. 12
0
 public void CreateReview(AlbumReviewDTO reviewDTO)
 {
     albumReviewService.CreateAlbumReview(reviewDTO);
 }
Esempio n. 13
0
        private static void TestAlbumReviewService()
        {
            List <int> list = new List <int>();

            albumReviewService = Container.Resolve <IAlbumReviewService>();
            clientService      = Container.Resolve <IClientService>();

            //Create
            albumReviewService.CreateAlbumReview(new AlbumReviewDTO
            {
                Text      = "This disc is a great improvement on an already brilliant EP, keeping the same style with great screams and guitars and improving melodically, lyrically and each song delivering a catchy chorus.",
                AlbumID   = albumID,
                CreatorID = clientID,
            });
            albumReviewService.CreateAlbumReview(new AlbumReviewDTO
            {
                Text      = "I remember listening to The Poison, 10 years ago when this style of metalcore was at an incredibly high popularity. I definitely didn’t hate it but still preferred to listen to other bands of even similar genres.",
                AlbumID   = albumID,
                CreatorID = clientID2,
            });

            //ListAllAlbumReviews
            var albumReviews = albumReviewService.ListAllAlbumReviews(new AlbumReviewFilter {
                AlbumID = albumID
            }, 1);

            Console.WriteLine(albumReviews.TotalResultCount == 2 ? "AlbumReviewService - TestListAllAlbumReviews - OK" : "AlbumReviewService - TestListAllAlbumReviews - FAIL");

            //GetAlbumReviewById
            var reviews = albumReviewService.ListAllAlbumReviews(new AlbumReviewFilter {
                CreatorIDs = new List <int> {
                    clientID
                }
            }, 1);
            AlbumReviewDTO albumReview  = reviews.ResultsPage.FirstOrDefault();
            var            testedReview = albumReviewService.GetAlbumReview(albumReview.ID);

            Console.WriteLine(testedReview.ID == albumReview.ID ? "AlbumReviewService - TestGetAlbumReviewById - OK" : "AlbumReviewService - TestGetAlbumReviewById - FAIL");

            //AddAlbumReview
            reviews = albumReviewService.ListAllAlbumReviews(new AlbumReviewFilter {
                CreatorIDs = new List <int> {
                    clientID2
                }
            }, 1);
            AlbumReviewDTO review2 = reviews.ResultsPage.FirstOrDefault();

            albumReviewService.AddReview(albumReview);
            albumReviewService.AddReview(review2);
            AlbumDTO album = albumService.GetAlbum(albumID);

            Console.WriteLine(album.ReviewIDs.Contains(review2.ID) ?
                              "AlbumReviewService - TestAddAlbumReview - OK" : "AlbumReviewService - TestAddAlbumReview - FAIL");

            //TestAlbumServisGetAllAlbumReviews
            Console.WriteLine(album.ReviewIDs.Count() == 2 ?
                              "AlbumService - TestAlbumServisGetAllAlbumReviews - OK" : "AlbumService - TestAlbumServisGetAllAlbumReviews - FAIL");

            //EditAlbumReview
            review2.Text = "1010";
            albumReviewService.EditAlbumReview(review2);
            AlbumReviewDTO review2FromDB = albumReviewService.GetAlbumReview(review2.ID);

            Console.WriteLine(review2FromDB.Text == "1010" ? "AlbumReviewService - TestEditAlbumReview - OK" : "AlbumReviewService - TestEditAlbumReview - FAIL");

            //DeleteAlbumReview
            albumReviewService.DeleteAlbumReview(review2.ID);
            AlbumReviewDTO venomFromDB = albumReviewService.GetAlbumReview(review2.ID);

            Console.WriteLine(venomFromDB == null ? "AlbumReviewService - TestDeleteAlbumReview - OK" : "AlbumReviewService - TestDeleteAlbumReview - FAIL");

            //GetCreator
            ClientDTO creator = albumReviewService.GetCreator(albumReview.ID);

            Console.WriteLine(creator.ID == clientID ? "AlbumReviewService - TestGetCreator - OK" : "AlbumReviewService - TestGetCreator - FAIL");
        }