public IHttpActionResult Get(int id, int newsId)
 {
     using (var _repo = new NewsRepository(UnitOfWork))
     {
         return Ok(_repo.All.FirstOrDefault(n => !n.IsDeleted && n.Id == newsId));
     }
 }
 public IHttpActionResult Get(int id)
 {
     using (var _repo = new NewsRepository(UnitOfWork))
     {
         return Ok(_repo.All.Where(n => !n.IsDeleted && n.ModuleId == id).OrderByDescending(n => n.Date).ToList());
     }
 }
        public void GetAllNews_ShouldReturnAllNews()
        {
            var context = new NewsContext();
            context.News.Delete();
            var firstNews = new Models.News()
            {
                Title = "Murder",
                Content = "A man was slaughterd in Sofia last night.",
                PublishDate = DateTime.Now
            };
            context.News.Add(firstNews);
            var secNews = new Models.News()
            {
                Title = "Eros Ramazzotti",
                Content = "Ramazzotti will sing in Sofia in September",
                PublishDate = DateTime.Now
            };
            context.News.Add(secNews);
            context.SaveChanges();
            var repo = new NewsRepository(context);
            var newsFromDB = repo.All().ToArray();
            Assert.IsNotNull(newsFromDB[0]);
            Assert.AreEqual(firstNews.Title, newsFromDB[0].Title);
            Assert.AreEqual(firstNews.Content, newsFromDB[0].Content);
            Assert.AreEqual(firstNews.PublishDate, newsFromDB[0].PublishDate);
            Assert.IsTrue(newsFromDB[0].Id != 0);

            Assert.IsNotNull(newsFromDB[1]);
            Assert.AreEqual(secNews.Title, newsFromDB[1].Title);
            Assert.AreEqual(secNews.Content, newsFromDB[1].Content);
            Assert.AreEqual(secNews.PublishDate, newsFromDB[1].PublishDate);
            Assert.IsTrue(newsFromDB[1].Id != 0);
        }
Example #4
0
 public NewsServices(PXHotelEntities entities)
 {
     _localizedResourceServices = HostContainer.GetInstance<ILocalizedResourceServices>();
     _newsCategoryServices = HostContainer.GetInstance<INewsCategoryServices>();
     _newsRepository = new NewsRepository(entities);
     _newsNewsCategoryRepository = new NewsNewsCategoryRepository(entities);
 }
        public void CreateNews_WhenNewsIsAddedToDbWithCorrectData_ShouldReturnNews()
        {
            // Arrange -> prapare the objects

            var repo = new NewsRepository(new NewsContext());
            var news = new Models.News()
            {
                Title = "Sample New News",
                PublishDate = DateTime.Now,
                Content = "Sample New News Content"
            };

            // Act -> perform some logic
            repo.Add(news);
            repo.SaveChanges();

            // Assert -> validate the results
            var newsFromDb = repo.Find(news.Id);

            Assert.IsNotNull(newsFromDb);
            Assert.AreEqual(news.Title, newsFromDb.Title);
            Assert.AreEqual(news.Content, newsFromDb.Content);
            Assert.AreEqual(news.PublishDate, newsFromDb.PublishDate);
            Assert.IsTrue(newsFromDb.Id != 0);
        }
        public void CreateAndAddInvalidNewsToDbShouldReturnError()
        {
            var repo = new NewsRepository(new NewsContext());

            var news = new News { Title = null };
            repo.Add(news);
            repo.SaveChanges();
        }
Example #7
0
 public NewsRepository GetNewsRepository()
 {
     if(newsRepository == null)
     {
         newsRepository = new NewsRepository();
     }
     return newsRepository;
 }
Example #8
0
        public void UpdateNews(tb_News newsModel)
        {
            _repository = new NewsRepository();
            _repository.UpdateNews(newsModel);

            //tb_News dbNews = _repository.GetSingle(d => d.News_Id == newsModel.News_Id);
            //dbNews = newsModel;
            //_repository.SaveChanges();
        }
Example #9
0
        public RepositoryData()
        {
            this._movieRepository = new MovieRepository();
            this._newsRepository = new NewsRepository();
            this._eventRepository = new EventRepository();
            this._loungeRepository= new LoungeItemRepository();

            this.movielist = new List<Movie>();
        }
Example #10
0
 public HttpResponseMessage GetAllNews()
 {
     var news = new NewsRepository().GetAllNews();
     return new HttpResponseMessage()
     {
         RequestMessage = Request,
         Content = new XmlContent(SimpleXmlConverter.ToXmlDocument(news, "NewsRoot"))
     };
 }
 /// <summary>
 /// 
 /// </summary>
 /// <param name="htmlHelper"></param>
 /// <param name="takeCount"></param>
 /// <returns></returns>
 public static IEnumerable<TB_News> GetNewsItemsOrderByDesc(this HtmlHelper htmlHelper, int takeCount)
 {
     using (var db = new NewsRepository())
     {
         return db.Find<TB_News>(s => s.IsDelete == false)
             .OrderByDescending(desc => desc.PostDateTime)
             .Take(takeCount).ToList();
     }
 }
        public IHttpActionResult Post(int id, string method)
        {
            using (NewsRepository _repo = new NewsRepository(UnitOfWork))
            {
                _repo.Delete(id);
                UnitOfWork.Save();
            }

            return Ok();
        }
        public void ModifyExistingNewsWithIncorrectData()
        {
            var repo = new NewsRepository(new NewsContext());

            var newsFromDb = repo.Find(1);

            newsFromDb.Title = null;

            repo.SaveChanges();
        }
Example #14
0
        public HttpResponseMessage GetAllNewsById(int id)
        {
            List<News> news = new NewsRepository().GetAllNews().ToList();

            return new HttpResponseMessage
            {
                RequestMessage = Request,
                Content = new XmlContent(SimpleXmlConverter.ToXmlDocument(news.FindAll(p => p.Id == id), "NewsRoot"))
            };
        }
        public void List_NewsRecords_Should_Return_Correct_List()
        {
            //Arrange
            NewsRepository repo = new NewsRepository(new NewsContext());
            var countBeforeAdding = repo.GetAll().Count();

            var news = new NewsRecord()
            {
                Title = "HardShit",
                Content = "Hard Shit in the mix",
                PublishDate = new DateTime(2015, 08, 30, 14, 04, 30)
            };
            var news2 = new NewsRecord()
            {
                Title = "SmokeShit",
                Content = "Smoke Shit in the mix",
                PublishDate = new DateTime(2015, 08, 30, 14, 04, 30)
            };

            var listNews = new List<NewsRecord>();
            listNews.Add(news);
            listNews.Add(news2);

            var newsBeforeAdd = repo.GetAll()
               .Select(n => n.Title)
               .ToList();

            var fakeNewsTitles = listNews
                .Select(n => n.Title)
                .ToList();

            fakeNewsTitles.AddRange(newsBeforeAdd);
            fakeNewsTitles.Sort();

            var fakeNewsTitlesOrd = fakeNewsTitles;
                 

            //Act
            repo.Add(news);
            repo.Add(news2);
            repo.SaveChanges();

            var allNews = repo.GetAll()
                .OrderBy(n => n.Title)
                .Select(n => n.Title)
                .ToList();

            //Assert
            Assert.AreEqual(2 + countBeforeAdding, repo.GetAll().Count());
            CollectionAssert.AreEqual(fakeNewsTitlesOrd, allNews);
        }
        public IHttpActionResult Post(News news)
        {
            using (UserRepository _userRepo = new UserRepository(UnitOfWork))
            {
                news.Author = _userRepo.All.First(u => u.UserName == User.Identity.Name);
                if (news.Id == default(int)) news.Date = DateTime.UtcNow;
                using (NewsRepository _repo = new NewsRepository(UnitOfWork))
                {
                    _repo.InsertOrUpdate(news);
                    UnitOfWork.Save();
                }
            }

            return Ok();
        }
        public void ModifyExistingNewsWithCorrectData()
        {
            var repo = new NewsRepository(new NewsContext());

            var newsFromDb = repo.Find(1);

            newsFromDb.Title = "Edited Title";
            newsFromDb.Content = "Some new content";

            repo.SaveChanges();

            Assert.IsNotNull(newsFromDb);
            Assert.AreEqual(newsFromDb.Title, "Edited Title");
            Assert.AreEqual(newsFromDb.Content, "Some new content");
            Assert.AreEqual(1, newsFromDb.Id);
        }
        public void GetAllNewsReturnNewsShouldReturnCorrectly()
        {
            var repo = new NewsRepository(new NewsContext());

            var news = new News
            {
                Title = "Test Title",
                Content = "Some test content.",
                PublishedDate = DateTime.Now
            };
            repo.Add(news);
            repo.SaveChanges();

            var newsDb = repo.Find(news.Id);

            Assert.IsNotNull(newsDb);
            Assert.AreEqual(news.Title, newsDb.Title);
            Assert.AreEqual(news.Content, newsDb.Content);
            Assert.AreEqual(news.PublishedDate, newsDb.PublishedDate);
        }
        public void Add_NewsRecord_Should_Add_NewsRecord_to_DB()
        {
            //Arrange
            NewsRepository repo = new NewsRepository(new NewsContext());
            var news = new NewsRecord()
            {
                Title = "HardShit",
                Content = "Hard Shit in the mix",
                PublishDate = new DateTime(2015, 08, 30, 14, 04, 30)
            };

            //Act
            repo.Add(news);
            repo.SaveChanges();

            //Assert
            var newsFromDb = repo.FindById(news.Id);

            Assert.IsNotNull(newsFromDb, "NewsRecord is not added to database");
            Assert.IsTrue(newsFromDb.Id != 0, "NewsRecord must have id !=0");
            Assert.AreEqual(news.Title, newsFromDb.Title, "Title is not corect");
            Assert.AreEqual(news.Content, newsFromDb.Content, "Content is not corect");
            Assert.AreEqual(news.PublishDate, newsFromDb.PublishDate, "Date is not corect");
        }
 public AccountService()
 {
     repository = new NewsRepository <Account>();
 }
Example #21
0
 public NewsServices()
 {
     _newsRepository = new NewsRepository();
 }
Example #22
0
        //[OutputCache(Duration = int.MaxValue, VaryByCustom = "lgg")]
        public ActionResult Index0310()
        {
            if (Request.Params["cc"] != null && Request.Params["cc"].ToString().ToLowerInvariant().Equals("true"))
            {
                _cacheManager.RemoveByPattern(ModelCacheEventConsumer.AF_HOME_PATTERN_KEY);

                _cacheManager.Remove(ModelCacheEventConsumer.CATEGORIES_KEY);
                _cacheManager.RemoveByPattern(ModelCacheEventConsumer.CATEGORIES_KEY);
                _cacheManager.Remove(ModelCacheEventConsumer.CATEGORY_PICTURES_KEY);
                _cacheManager.RemoveByPattern(ModelCacheEventConsumer.CATEGORY_PICTURES_KEY);
                _cacheManager.RemoveByPattern(ModelCacheEventConsumer.CATEGORY_MANUFACTURES_PATTERN_KEY);
                _cacheManager.Remove(ModelCacheEventConsumer.HOMEPAGE_MANUFACTURES_BANNER_KEY);
                _cacheManager.RemoveByPattern(ModelCacheEventConsumer.HOMEPAGE_MANUFACTURES_BANNER_KEY);
                _cacheManager.Remove(ModelCacheEventConsumer.HOME_PAGE_PRODUCTS);
                _cacheManager.RemoveByPattern(ModelCacheEventConsumer.HOME_PAGE_PRODUCTS_PATTERN_KEY);

                //var cacheManager = new MemoryCacheManager();
                //cacheManager.Remove
            }

            NewsRepository nr = new NewsRepository();

            //ViewBag.NewItemsHomeMainContent = nr.NewItemsBySystemType(_workContext.WorkingLanguage.Id, NewsType.HomeMainContent, 4);
            //ViewBag.NewItems = nr.NewItemsBySystemType(_workContext.WorkingLanguage.Id, NewsType.News, 3, NewsItemPictureType.Thumb);
            ViewBag.NewItemsHomeMainContent = _cacheManager.Get(string.Format(ModelCacheEventConsumer.NEWS_MODEL_BY_TYPE_NEWS, _workContext.WorkingLanguage.Id, (int)NewsType.HomeMainContent, 4),
                                                                3600, () => nr.NewItemsBySystemType(_workContext.WorkingLanguage.Id, NewsType.HomeMainContent, 4));
            ViewBag.NewItems = _cacheManager.Get(string.Format(ModelCacheEventConsumer.NEWS_MODEL_BY_TYPE_NEWS, _workContext.WorkingLanguage.Id, (int)NewsType.News, 3),
                                                 3600, () => nr.NewItemsBySystemType(_workContext.WorkingLanguage.Id, NewsType.News, 3, NewsItemPictureType.Thumb));


            //var bottomNews = _newsService.GetAllNews(_workContext.WorkingLanguage.Id, null, null, NewsType.HomeBottomContent, 0, 5);
            //ViewBag.BottomContentItemsNews = bottomNews.ToContentItems(_pictureService);
            var bottomNews = _cacheManager.Get(string.Format(ModelCacheEventConsumer.NEWS_MODEL_BY_TYPE_HOMEBOTTOMCONTENT, _workContext.WorkingLanguage.Id),
                                               3600, () => _newsService.GetAllNews(_workContext.WorkingLanguage.Id, null, null, NewsType.HomeBottomContent, 0, 5));

            ViewBag.BottomContentItemsNews = bottomNews.ToContentItems(_pictureService);


            //var bottomSlider = _newsService.GetAllNews(_workContext.WorkingLanguage.Id, null, null, NewsType.HomeSlider, 0, 10);
            //ViewBag.BottomSliderContentItems = bottomSlider.ToContentItems(_pictureService);
            var bottomSlider = _cacheManager.Get(string.Format(ModelCacheEventConsumer.NEWS_MODEL_BY_TYPE_HOMESLIDER, _workContext.WorkingLanguage.Id),
                                                 3600, () => _newsService.GetAllNews(_workContext.WorkingLanguage.Id, null, null, NewsType.HomeSlider, 0, 10));

            ViewBag.BottomSliderContentItems = bottomSlider.ToContentItems(_pictureService);


            //var homeManufacturers = _newsService.GetAllNews(2/*TR*/, null, null, NewsType.HomeManufacturers, 0, 10);
            //ViewBag.HomeManufacturers = homeManufacturers.ToContentItems(_pictureService);
            var homeManufacturers = _cacheManager.Get(string.Format(ModelCacheEventConsumer.NEWS_MODEL_BY_TYPE_HOMEMANUFACTURER, _workContext.WorkingLanguage.Id),
                                                      3600, () => _newsService.GetAllNews(2 /*TR*/, null, null, NewsType.HomeManufacturers, 0, 10));

            ViewBag.HomeManufacturers = homeManufacturers.ToContentItems(_pictureService);


            //var homeContentBanner = _newsService.GetAllNews(_workContext.WorkingLanguage.Id, null, null, NewsType.HomeContentBanner, 0, 1);
            //ViewBag.HomeContentBanner = homeContentBanner.ToContentItems(_pictureService);
            var homeContentBanner = _cacheManager.Get(string.Format(ModelCacheEventConsumer.NEWS_MODEL_BY_TYPE_HOMECONTENTBANNER, _workContext.WorkingLanguage.Id),
                                                      3600, () => _newsService.GetAllNews(_workContext.WorkingLanguage.Id, null, null, NewsType.HomeContentBanner, 0, 1));

            ViewBag.HomeContentBanner = homeContentBanner.ToContentItems(_pictureService);


            return(View());
        }
Example #23
0
 public NewsViewModel(NewsRepository news)
 {
     _newsRepository = news;
 }
        public void Add_Empty_Sting_Title_News_Record_Should_Throw_Exception()
        {
            // Arrange -> prapare the objects
            NewsRepository repo = new NewsRepository(new NewsContext());
            var invalidNewsRecord = new NewsRecord()
            {
                Title = "",
                Content = "Oh big Shit"
            };

            // Act -> perform some logic
            repo.Add(invalidNewsRecord);
            repo.SaveChanges();

            // Assert -> expect an exception
        }
Example #25
0
 public NewsController(NewsRepository newsRepository, SetupRepository setupRepository, PaginatedMetaService paginatedMetaService)
 {
     _newsRepository       = newsRepository;
     _paginatedMetaService = paginatedMetaService;
     _setupRepository      = setupRepository;
 }
Example #26
0
 public NewsServiceImpl(neighlinkdbContext dbContext)
 {
     _newsRepository = new NewsRepository(dbContext);
 }
Example #27
0
 public NewsController()
 {
     newsRepository = new NewsRepository();
 }
        public void TryToDeleteNonExistingNews()
        {
            var repo = new NewsRepository(new NewsContext());

            var newsFromDb = repo.Find(5);

            repo.Delete(newsFromDb);
        }
        public void Modify_Existing_Data_With_Incorrect_Data_Should_Throw_Exception()
        {
            NewsRepository repo = new NewsRepository(new NewsContext());
            var news = new NewsRecord()
            {
                Title = "UnModifiedShit",
                Content = "See me updated",
                PublishDate = new DateTime(2015, 08, 30, 14, 04, 30)
            };

            repo.Add(news);
            repo.SaveChanges();

            var newsFromDB = repo.GetAll().FirstOrDefault(n => n.Title == "UnModifiedShit");
            newsFromDB.Title = "";

            repo.Update(news);
            repo.SaveChanges();
        }
        public void Delete_Existing_Data_Should_Delete_The_Data()
        {
            NewsRepository repo = new NewsRepository(new NewsContext());
            var news = new NewsRecord()
            {
                Title = "UnModifiedShit",
                Content = "See me updated",
                PublishDate = new DateTime(2015, 08, 30, 14, 04, 30)
            };

            repo.Add(news);
            repo.SaveChanges();

            var countBeforeDeletion = repo.GetAll().Count();

            var newsFromDB = repo.GetAll().FirstOrDefault(n => n.Title == "UnModifiedShit");
            repo.Delete(newsFromDB);
            repo.SaveChanges();

            Assert.AreEqual(countBeforeDeletion - 1, repo.GetAll().Count());
        }
Example #31
0
        public ActionResult Find(string tags)
        {
            var notas = NewsRepository.FindNews(tags);

            return(View("Index", notas));
        }
Example #32
0
        // GET: News/Details/5
        public ActionResult Details(int id)
        {
            var nota = NewsRepository.GetNew(id);

            return(View(nota));
        }
Example #33
0
        public ActionResult Index()
        {
            var notas = NewsRepository.GetNews();

            return(View(notas));
        }
Example #34
0
        public ActionResult Delete(int?id)
        {
            var nota = NewsRepository.GetNew(id);

            return(View(nota));
        }
Example #35
0
 public NewspaperService()
 {
     repository = new NewsRepository <Newspaper>();
 }
        public void DeleteExistingNews()
        {
            var repo = new NewsRepository(new NewsContext());

            var newsFromDb = repo.Find(1);

            repo.Delete(newsFromDb);
            repo.SaveChanges();

            Assert.IsNull(repo.Find(1));
        }
 public HomeController()
 {
     newsRepository = new NewsRepository();
 }
Example #38
0
        public static bool Create(News news)
        {
            INewsRepository newsRepo = new NewsRepository();

            return(newsRepo.Create(news));
        }
Example #39
0
        public static bool Delete(int id)
        {
            INewsRepository newsRepo = new NewsRepository();

            return(newsRepo.Delete(id));
        }
Example #40
0
 public NewsController()
 {
     _repository = new NewsRepository(new GameContext());
 }
 public void TestInit()
 {
     transaction = new TransactionScope();
     newsRepo    = new NewsRepository();
 }
        public void ModifyNonExistingNewsShouldTrhowException()
        {
            var repo = new NewsRepository(new NewsContext());

            var newsFromDb = repo.Find(5);
            newsFromDb.Title = "NonExisting entity";
        }
Example #43
0
 public NewsController()
 {
     oNewsRepository = new NewsRepository();
 }
Example #44
0
 public NewsController()
 {
     news_repo = new NewsRepository();
     cat_repo  = new CategoryRepository();
     com_repo  = new CommentRepository();
 }
 public UserService()
 {
     repository = new NewsRepository <User>();
 }
Example #46
0
 public HomeController()
 {
     newsRepository = new NewsRepository();
     roomRepository = new RoomRepository();
 }
Example #47
0
 public BlogController(NewsRepository newsRepository) : base()
 {
     _newsRepository = newsRepository;
 }
        public void Modify_Existing_Data_Should_Update_The_Data()
        {
            NewsRepository repo = new NewsRepository(new NewsContext());
            var news = new NewsRecord()
            {
                Title = "UnModifiedShit",
                Content = "See me updated",
                PublishDate = new DateTime(2015, 08, 30, 14, 04, 30)
            };

            repo.Add(news);
            repo.SaveChanges();

            var newsFromDB = repo.GetAll().FirstOrDefault(n => n.Title == "UnModifiedShit");
            newsFromDB.Title = "ModifiedShit";

            repo.Update(news);
            repo.SaveChanges();

            var changedNews = repo.GetAll().FirstOrDefault(n => n.Title == "ModifiedShit");

            Assert.AreEqual("ModifiedShit", changedNews.Title);
        }
Example #49
0
        public ActionResult Index()
        {
            var all = NewsRepository.GetAll();

            return(View(all));
        }
        public void Modify_Non_Existing_Data_Should_Throw_Exception()
        {
            NewsRepository repo = new NewsRepository(new NewsContext());

            var newsFromDB = repo.GetAll().FirstOrDefault(n => n.Id == 1500);
            newsFromDB.Title = "Ihaaaaa";

            repo.Update(newsFromDB);
            repo.SaveChanges();
        }
Example #51
0
 public NewsService(NewsRepository entityRepository) : base(entityRepository, new List <string>() { "CategoryList", "Details" })
 {
     _entityRepository = entityRepository;
 }
        public void Delete_Non_Existing_Data_Should_Throw_Exception()
        {
            NewsRepository repo = new NewsRepository(new NewsContext());

            var newsFromDB = repo.GetAll().FirstOrDefault(n => n.Id == 1500);

            repo.Delete(newsFromDB);
            repo.SaveChanges();

        }
Example #53
0
 public void Initiaize()
 {
     this.tran = new TransactionScope();
     this.repo = new NewsRepository(new NewsContext());
 }
Example #54
0
        public NewsController()
        {
            ApplicationDbContext context = new ApplicationDbContext();

            news = new NewsRepository(context);
        }
Example #55
0
 public IActionResult NewsList()
 {
     return(View(NewsRepository.GetAllNews()));
 }