public async Task <IActionResult> Add([FromBody] WatchListViewModel watchListViewModel)
{
try
{
bool isExistedWatchListByStudentIdAndCourseId = await watchListRepository.IsExistedWatchListByStudentIdAndCourseId(watchListViewModel.StudentId, watchListViewModel.CourseId);
if (isExistedWatchListByStudentIdAndCourseId == true)
{
return(BadRequest(new
{
Errors = new { Code = "ExistedWatchList", Description = "WatchList has already existed!" }
}));
}
WatchList watchListMapped = mapper.Map <WatchList>(watchListViewModel);
await watchListRepository.Add(watchListMapped);
return(Ok(new
{
Results = watchListMapped
}));
}
catch (Exception e)
{
Console.WriteLine($"ErrorMesages: {e}");
return(BadRequest(new
{
Errors = new { Code = "InvalidInputParameters", Description = "Invalid Input Parameters!" }
}));
}
}
public IActionResult Index()
{
var vm = new WatchListViewModel();
vm.MostPopularSeries = watchListLogic.GetMostPopularSeries();
return(View(vm));
}
//Passing id as a parameter, represents the Member Id.
//In this action we are consolidating the watchlists into a view per individual member
public ActionResult Dashboard(int id)
{
var viewModel = new WatchListViewModel
{
MemberId = id
};
return(View(viewModel));
}
// GET: WatchList
public ActionResult Index()
{
WatchListViewModel model = new WatchListViewModel();
int currentUser = (int)Session["userId"];
var movieList = db.Watchlist.Where(u => u.UserID == currentUser).ToList();
return(View(movieList.ToList()));
}
public RemoveStockCommand(
WatchListViewModel watchListViewModel,
IUserManager userManager,
IUserStockMappingDataService userStockMappingDataService)
{
this.watchListViewModel = watchListViewModel;
this.userManager = userManager;
this.userStockMappingDataService = userStockMappingDataService;
}
public ViewResult Index(int userid)
{
var watchListViewModel = new WatchListViewModel()
{
Series = watchListLogic.GetSeries(userid)
};
return(View(watchListViewModel));
}
public IActionResult WatchList()
{
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
WatchListViewModel watchListViewModel = new WatchListViewModel
{
WatchLists = _watchListRepository.GetWatchListsByUserId(userId)
};
return(View(watchListViewModel));
}
public SearchSymbolCommand(
WatchListViewModel watchListViewModel,
IStockService stockService,
IUserStockMappingDataService userStockMappingDataService,
IUserManager userManager)
{
this.watchListViewModel = watchListViewModel;
this.stockService = stockService;
this.userStockMappingDataService = userStockMappingDataService;
this.userManager = userManager;
}
public void WhenCurrentWatchItemSet_PropertyIsUpdated()
{
// Prepare
MockMarketPricesUpdatedEvent marketPricesUpdatedEvent = new MockMarketPricesUpdatedEvent();
Mock <TickerSymbolSelectedEvent> mockTickerSymbolSelectedEvent = new Mock <TickerSymbolSelectedEvent>();
ObservableCollection <string> watchList = new ObservableCollection <string>();
watchList.Add("A");
watchList.Add("B");
watchList.Add("C");
Mock <IWatchListService> mockWatchListService = new Mock <IWatchListService>();
mockWatchListService.Setup(x => x.RetrieveWatchList()).Returns(watchList).Verifiable();
Mock <IMarketFeedService> mockMarketFeedService = new Mock <IMarketFeedService>();
mockMarketFeedService.Setup(x => x.GetPrice("A")).Returns(1);
mockMarketFeedService.Setup(x => x.GetPrice("B")).Returns(2);
mockMarketFeedService.Setup(x => x.GetPrice("C")).Returns(3);
Mock <IRegionManager> mockRegionManager = new Mock <IRegionManager>();
Mock <IEventAggregator> mockEventAggregator = new Mock <IEventAggregator>();
mockEventAggregator.Setup(x => x.GetEvent <MarketPricesUpdatedEvent>()).Returns(marketPricesUpdatedEvent);
mockEventAggregator.Setup(x => x.GetEvent <TickerSymbolSelectedEvent>()).Returns(mockTickerSymbolSelectedEvent.Object);
IWatchListService watchListService = mockWatchListService.Object;
IMarketFeedService marketFeedService = mockMarketFeedService.Object;
IRegionManager regionManager = mockRegionManager.Object;
IEventAggregator eventAggregator = mockEventAggregator.Object;
WatchListViewModel target = new WatchListViewModel(watchListService, marketFeedService, regionManager, eventAggregator);
bool propertyChangedRaised = false;
target.PropertyChanged += delegate(object sender, PropertyChangedEventArgs e)
{
if (e.PropertyName == "CurrentWatchItem")
{
propertyChangedRaised = true;
}
};
// Act
target.CurrentWatchItem = target.WatchListItems[1];
// Verify
Assert.AreSame(target.WatchListItems[1], target.CurrentWatchItem);
Assert.IsTrue(propertyChangedRaised);
}
public void WhenMarketPriceChagnes_PriceUpdated()
{
// Prepare
MockMarketPricesUpdatedEvent marketPricesUpdatedEvent = new MockMarketPricesUpdatedEvent();
ObservableCollection <string> watchList = new ObservableCollection <string>();
watchList.Add("A");
watchList.Add("B");
watchList.Add("C");
Mock <IWatchListService> mockWatchListService = new Mock <IWatchListService>();
mockWatchListService.Setup(x => x.RetrieveWatchList()).Returns(watchList).Verifiable();
Mock <IMarketFeedService> mockMarketFeedService = new Mock <IMarketFeedService>();
mockMarketFeedService.Setup(x => x.GetPrice("A")).Returns(1);
mockMarketFeedService.Setup(x => x.GetPrice("B")).Returns(2);
mockMarketFeedService.Setup(x => x.GetPrice("C")).Returns(3);
Mock <IRegionManager> mockRegionManager = new Mock <IRegionManager>();
Mock <IEventAggregator> mockEventAggregator = new Mock <IEventAggregator>();
mockEventAggregator.Setup(x => x.GetEvent <MarketPricesUpdatedEvent>()).Returns(marketPricesUpdatedEvent);
IWatchListService watchListService = mockWatchListService.Object;
IMarketFeedService marketFeedService = mockMarketFeedService.Object;
IRegionManager regionManager = mockRegionManager.Object;
IEventAggregator eventAggregator = mockEventAggregator.Object;
WatchListViewModel target = new WatchListViewModel(watchListService, marketFeedService, regionManager, eventAggregator);
Dictionary <string, decimal> newPrices = new Dictionary <string, decimal>()
{
{ "A", 10 },
{ "B", 20 },
{ "C", 30 },
};
// Act
marketPricesUpdatedEvent.Publish(newPrices);
// Verify
Assert.AreEqual(3, target.WatchListItems.Count);
Assert.AreEqual(10, target.WatchListItems[0].CurrentPrice);
Assert.AreEqual(20, target.WatchListItems[1].CurrentPrice);
Assert.AreEqual(30, target.WatchListItems[2].CurrentPrice);
}
public void WhenWatchListItemAdded_NavigatesToWatchListView()
{
// Prepare
MockMarketPricesUpdatedEvent marketPricesUpdatedEvent = new MockMarketPricesUpdatedEvent();
ObservableCollection <string> watchList = new ObservableCollection <string>();
watchList.Add("A");
watchList.Add("B");
watchList.Add("C");
Mock <IWatchListService> mockWatchListService = new Mock <IWatchListService>();
mockWatchListService.Setup(x => x.RetrieveWatchList()).Returns(watchList).Verifiable();
Mock <IMarketFeedService> mockMarketFeedService = new Mock <IMarketFeedService>();
mockMarketFeedService.Setup(x => x.GetPrice("A")).Returns(1);
mockMarketFeedService.Setup(x => x.GetPrice("B")).Returns(2);
mockMarketFeedService.Setup(x => x.GetPrice("C")).Returns(3);
Mock <IRegion> mockMainRegion = new Mock <IRegion>();
mockMainRegion.Setup(x => x.RequestNavigate(new Uri("/WatchListView", UriKind.RelativeOrAbsolute), It.IsAny <Action <NavigationResult> >())).Verifiable();
Mock <IRegionManager> mockRegionManager = new Mock <IRegionManager>();
mockRegionManager.Setup(x => x.Regions[RegionNames.MainRegion]).Returns(mockMainRegion.Object);
Mock <IEventAggregator> mockEventAggregator = new Mock <IEventAggregator>();
mockEventAggregator.Setup(x => x.GetEvent <MarketPricesUpdatedEvent>()).Returns(marketPricesUpdatedEvent);
IWatchListService watchListService = mockWatchListService.Object;
IMarketFeedService marketFeedService = mockMarketFeedService.Object;
IRegionManager regionManager = mockRegionManager.Object;
IEventAggregator eventAggregator = mockEventAggregator.Object;
WatchListViewModel target = new WatchListViewModel(watchListService, marketFeedService, regionManager, eventAggregator);
// Act
target.WatchListItems.Add(new WatchItem("D", 20));
// Verify
mockMainRegion.Verify(x => x.RequestNavigate(new Uri("/WatchListView", UriKind.RelativeOrAbsolute), It.IsAny <Action <NavigationResult> >()), Times.Once());
}
public void WhenRemoveCommandExecuted_RemovesWatchEntry()
{
// Prepare
MockMarketPricesUpdatedEvent marketPricesUpdatedEvent = new MockMarketPricesUpdatedEvent();
ObservableCollection <string> watchList = new ObservableCollection <string>();
watchList.Add("A");
watchList.Add("B");
watchList.Add("C");
Mock <IWatchListService> mockWatchListService = new Mock <IWatchListService>();
mockWatchListService.Setup(x => x.RetrieveWatchList()).Returns(watchList).Verifiable();
Mock <IMarketFeedService> mockMarketFeedService = new Mock <IMarketFeedService>();
mockMarketFeedService.Setup(x => x.GetPrice("A")).Returns(1);
mockMarketFeedService.Setup(x => x.GetPrice("B")).Returns(2);
mockMarketFeedService.Setup(x => x.GetPrice("C")).Returns(3);
Mock <IRegion> mockMainRegion = new Mock <IRegion>();
Mock <IRegionManager> mockRegionManager = new Mock <IRegionManager>();
mockRegionManager.Setup(x => x.Regions[RegionNames.MainRegion]).Returns(mockMainRegion.Object);
Mock <IEventAggregator> mockEventAggregator = new Mock <IEventAggregator>();
mockEventAggregator.Setup(x => x.GetEvent <MarketPricesUpdatedEvent>()).Returns(marketPricesUpdatedEvent);
IWatchListService watchListService = mockWatchListService.Object;
IMarketFeedService marketFeedService = mockMarketFeedService.Object;
IRegionManager regionManager = mockRegionManager.Object;
IEventAggregator eventAggregator = mockEventAggregator.Object;
WatchListViewModel target = new WatchListViewModel(watchListService, marketFeedService, regionManager, eventAggregator);
// Act
target.RemoveWatchCommand.Execute("A");
// Verify
Assert.AreEqual(2, target.WatchListItems.Count);
}
public void WhenCurrentWatchItemSet_TickerSymbolSelectedEventRaised()
{
// Prepare
MockMarketPricesUpdatedEvent marketPricesUpdatedEvent = new MockMarketPricesUpdatedEvent();
Mock <TickerSymbolSelectedEvent> mockTickerSymbolSelectedEvent = new Mock <TickerSymbolSelectedEvent>();
mockTickerSymbolSelectedEvent.Setup(x => x.Publish("B")).Verifiable();
ObservableCollection <string> watchList = new ObservableCollection <string>();
watchList.Add("A");
watchList.Add("B");
watchList.Add("C");
Mock <IWatchListService> mockWatchListService = new Mock <IWatchListService>();
mockWatchListService.Setup(x => x.RetrieveWatchList()).Returns(watchList).Verifiable();
Mock <IMarketFeedService> mockMarketFeedService = new Mock <IMarketFeedService>();
mockMarketFeedService.Setup(x => x.GetPrice("A")).Returns(1);
mockMarketFeedService.Setup(x => x.GetPrice("B")).Returns(2);
mockMarketFeedService.Setup(x => x.GetPrice("C")).Returns(3);
Mock <IRegionManager> mockRegionManager = new Mock <IRegionManager>();
Mock <IEventAggregator> mockEventAggregator = new Mock <IEventAggregator>();
mockEventAggregator.Setup(x => x.GetEvent <MarketPricesUpdatedEvent>()).Returns(marketPricesUpdatedEvent);
mockEventAggregator.Setup(x => x.GetEvent <TickerSymbolSelectedEvent>()).Returns(mockTickerSymbolSelectedEvent.Object);
IWatchListService watchListService = mockWatchListService.Object;
IMarketFeedService marketFeedService = mockMarketFeedService.Object;
IRegionManager regionManager = mockRegionManager.Object;
IEventAggregator eventAggregator = mockEventAggregator.Object;
WatchListViewModel target = new WatchListViewModel(watchListService, marketFeedService, regionManager, eventAggregator);
// Act
target.CurrentWatchItem = target.WatchListItems[1];
// Verify
mockTickerSymbolSelectedEvent.VerifyAll();
}
public void WhenConstructed_IntializesValues()
{
// Prepare
MockMarketPricesUpdatedEvent marketPricesUpdatedEvent = new MockMarketPricesUpdatedEvent();
ObservableCollection <string> watchList = new ObservableCollection <string>();
watchList.Add("A");
watchList.Add("B");
watchList.Add("C");
Mock <IWatchListService> mockWatchListService = new Mock <IWatchListService>();
mockWatchListService.Setup(x => x.RetrieveWatchList()).Returns(watchList).Verifiable();
Mock <IMarketFeedService> mockMarketFeedService = new Mock <IMarketFeedService>();
mockMarketFeedService.Setup(x => x.GetPrice("A")).Returns(1);
mockMarketFeedService.Setup(x => x.GetPrice("B")).Returns(2);
mockMarketFeedService.Setup(x => x.GetPrice("C")).Returns(3);
Mock <IRegionManager> mockRegionManager = new Mock <IRegionManager>();
Mock <IEventAggregator> mockEventAggregator = new Mock <IEventAggregator>();
mockEventAggregator.Setup(x => x.GetEvent <MarketPricesUpdatedEvent>()).Returns(marketPricesUpdatedEvent);
IWatchListService watchListService = mockWatchListService.Object;
IMarketFeedService marketFeedService = mockMarketFeedService.Object;
IRegionManager regionManager = mockRegionManager.Object;
IEventAggregator eventAggregator = mockEventAggregator.Object;
// Act
WatchListViewModel actual = new WatchListViewModel(watchListService, marketFeedService, regionManager, eventAggregator);
// Verify
Assert.IsNotNull(actual);
Assert.AreEqual("WATCH LIST", actual.HeaderInfo);
Assert.AreEqual(3, actual.WatchListItems.Count);
Assert.IsNull(actual.CurrentWatchItem);
Assert.IsNotNull(actual.RemoveWatchCommand);
mockWatchListService.VerifyAll();
}
public async Task <IActionResult> WatchList()
{
var watchList = await _userManager.GetWatchListAsync(HttpContext.User);
WatchListViewModel watchListViewModel = new WatchListViewModel();
if (watchList != null)
{
foreach (var watch in watchList)
{
var result = await _movieService.GetDetailsAsync(watch.MovieId);
if (result.IsSuccessful)
{
watchListViewModel.WatchListDetailViewModels.Add(_mapper.Map <WatchListDetailViewModel>(result.Data));
}
}
var userId = _userManager.GetUserId(HttpContext.User);
try
{
using (CountWebServiceSoapClient client = new CountWebServiceSoapClient(CountWebServiceSoapClient.EndpointConfiguration.CountWebServiceSoap))
{
var response = await client.WatchListCountAsync(userId);
watchListViewModel.Count = response.Body.WatchListCountResult;
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(RedirectToAction("ErrorWithModel", "Error", new ErrorViewModel {
MessageTitle = e.Message
}));
}
}
return(View(watchListViewModel));
}
public async Task <IActionResult> Update([FromBody] WatchListViewModel watchListViewModel)
{
try
{
WatchList watchListMapped = mapper.Map <WatchList>(watchListViewModel);
await watchListRepository.Update(watchListMapped);
return(Ok(new
{
Results = watchListMapped
}));
}
catch (Exception e)
{
Console.WriteLine($"ErrorMesages: {e}");
return(BadRequest(new
{
Errors = new { Code = "InvalidInputParameters", Description = "Invalid Input Parameters!" }
}));
}
}
//Passing id as a parameter, represents the Member Id.
//In this action we are consolidating the watchlists into a view per individual member
public ActionResult Member(int id)
{
//if (id == null)
// return HttpNotFound();
//For the members' specific episode viewing list, include watchlists from the
//WatchLists table where the member Id is equal to the parameter passed to the action.
//STEP 1) Important for understanding. This returns a list of tv shows, where the member id
// field is equal to what's passed to this method.
//var tvShows = _context.WatchLists
// .Where(t => t.Member.Id == id)
// .ToList();
//STEP 2) Important for understanding. By including the TvShow model, we then get the details
// of the shows that are included in the query.
//var tvShows = _context.WatchLists
// .Include(t => t.TvShow)
// .Include(t => t.Member)
// .Where(t => t.Member.Id == id)
// //.Single();
// .ToList();
//if (tvShows == null)
// return HttpNotFound();
var viewModel = new WatchListViewModel
{
//TBD - LEFT off here
MemberId = id
//Member = member,
//TvShows = .TvShows.ToList(),
//WatchLists = member.WatchLists.ToList()
};
return(View(viewModel));
}
public void WhenMarketPriceNotAvailable_PriceSetToNull()
{
// Prepare
MockMarketPricesUpdatedEvent marketPricesUpdatedEvent = new MockMarketPricesUpdatedEvent();
ObservableCollection <string> watchList = new ObservableCollection <string>();
watchList.Add("A");
Mock <IWatchListService> mockWatchListService = new Mock <IWatchListService>();
mockWatchListService.Setup(x => x.RetrieveWatchList()).Returns(watchList).Verifiable();
Mock <IMarketFeedService> mockMarketFeedService = new Mock <IMarketFeedService>();
mockMarketFeedService.Setup(x => x.GetPrice("A")).Throws(new ArgumentException("tickerSymbol"));
Mock <IRegionManager> mockRegionManager = new Mock <IRegionManager>();
Mock <IEventAggregator> mockEventAggregator = new Mock <IEventAggregator>();
mockEventAggregator.Setup(x => x.GetEvent <MarketPricesUpdatedEvent>()).Returns(marketPricesUpdatedEvent);
IWatchListService watchListService = mockWatchListService.Object;
IMarketFeedService marketFeedService = mockMarketFeedService.Object;
IRegionManager regionManager = mockRegionManager.Object;
IEventAggregator eventAggregator = mockEventAggregator.Object;
// Act
WatchListViewModel actual = new WatchListViewModel(watchListService, marketFeedService, regionManager, eventAggregator);
// Verify
Assert.IsNotNull(actual);
Assert.AreEqual(1, actual.WatchListItems.Count);
Assert.AreEqual("A", actual.WatchListItems[0].TickerSymbol);
Assert.AreEqual(null, actual.WatchListItems[0].CurrentPrice);
}
public WatchListPage()
{
InitializeComponent();
BindingContext = new WatchListViewModel();
}
