public async Task <IActionResult> AddComment(BarViewModel bar)
{
int userId = int.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier));
var author = HttpContext.User.Identity.Name;
var barComment = new BarCommentViewModel
{
Text = bar.CurrentComment,
BarId = bar.Id,
UserId = userId,
Author = author,
};
var barCommentDto = this.barCommentVmMapper.MapDTO(barComment);
var comment = await this.BarCommentsService.CreateCommentAsync(barCommentDto);
var currentBar = await this.barService.GetBarAsync(comment.BarId);
var barVM = this.barVmMapper.MapViewModel(currentBar);
var DtoComments = await this.BarCommentsService.GetBarCommentsAsync(barVM.Id);
barVM.Comments = this.barCommentVmMapper.MapViewModel(DtoComments);
barVM.AverageRating = this.barRatingService.GetAverageBarRating(bar.Id);
return(RedirectToAction("Details", "Bars", new { area = "", id = barVM.Id }));
}
public async Task <IActionResult> CreateBar(BarViewModel barViewModel)
{
if (await _barServices.BarWithThatNameExists(barViewModel.Name))
{
ModelState.AddModelError(string.Empty, "Bar with that name already exists.");
return(View());
}
if (!ModelState.IsValid)
{
return(View());
}
var query = barViewModel.FormatApiTemplate(barViewModel.Address.Split(' '));
var apiResult = await this._apiServices.CallApiAsync(query);
barViewModel.ParseApiResult(apiResult);
var barModel = await barViewModel.MapToEntity();
await _barServices.CreateBarAsync(barModel);
foreach (var cocktail in barViewModel.Cocktails)
{
var cocktailEntity = await _cocktailServices.GetAsync(cocktail);
await _barCocktailServices.CreateAsync(barModel, cocktailEntity);
}
return(RedirectToAction("Index", "Home"));
}
public void CallBarsService_GetByIdMethod_WithCorrectIdWhenItIsPassed()
{
//Arrange
var bar = new ShishaBar();
var barViewModel = new BarViewModel();
string userId = "1";
int rating = 5;
var mockedMappingService = new Mock <IMappingService>();
mockedMappingService.Setup(x => x.Map <ShishaBar, BarViewModel>(bar)).Returns(barViewModel);
var mockedBarsService = new Mock <IBarsService>();
mockedBarsService.Setup(x => x.GetBarById(It.IsAny <int>())).Returns(bar);
var mockedReviewsService = new Mock <IReviewsService>();
var mockedRatingService = new Mock <IRatingService>();
mockedRatingService.Setup(x => x.GetUserRating(It.IsAny <int>(), userId)).Returns(rating);
var mockedUserProvider = new Mock <IUserProvider>();
mockedUserProvider.Setup(x => x.GetUserId()).Returns(userId);
var controller = new BarController(mockedMappingService.Object,
mockedBarsService.Object,
mockedReviewsService.Object,
mockedRatingService.Object,
mockedUserProvider.Object);
//Act
controller.Index(2);
//Assert
mockedBarsService.Verify(x => x.GetBarById(2), Times.Once());
}
public async Task <IActionResult> UpdateAvailableCocktails(BarViewModel tempBarVm)
{
var bar = await this.context.Bars
.Where(b => b.IsDeleted == false)
.Include(b => b.BarCocktails)
.ThenInclude(bc => bc.Cocktail)
.FirstOrDefaultAsync(bar => bar.Id == tempBarVm.Id);
this.context.BarCocktails.RemoveRange(bar.BarCocktails);
await this.context.SaveChangesAsync();
var cocktailsForBar = await this.cocktailService.GetBarCocktailsAsync(bar.Id);
var cocktailsForBarIds = cocktailsForBar.Select(c => c.Id);
foreach (var item in tempBarVm.SelectedCocktails)
{
if (item.isChecked == true && !cocktailsForBarIds.Contains(item.Id))
{
await this.barCocktailsService.CreateBarCocktail(bar.Id, item.Id);
}
}
return(RedirectToAction("Details", "Bars", new { area = "", id = bar.Id }));
}
public async Task <IActionResult> AvailableCocktails(int barId)
{
var bar = await this.barService.GetBarAsync(barId);
var allCocktails = await this.cocktailService.GetAllCocktailsAsync();
var allCocktailsVm = allCocktails
.Select(x => this.cocktailVmMapper.MapViewModel(x))
.Select(x => new CheckBoxItem()
{
Id = x.Id,
Title = x.Name,
isChecked = context.BarCocktails.Any(bc => bc.BarId == barId && bc.CocktailId == x.Id) ? true : false,
}).ToList();
var availableCocktails = await this.cocktailService.GetBarCocktailsAsync(barId);
var availableCocktailsVm = this.cocktailVmMapper.MapViewModel(availableCocktails);
var barVm = new BarViewModel
{
Id = bar.Id,
Name = bar.Name,
SelectedCocktails = allCocktailsVm,
Cocktails = availableCocktailsVm,
};
return(View(barVm));
}
public BarViewModel MapToVMFromDTO(BarDTO barDTO)
{
if (barDTO == null)
{
return(null);
}
var barVM = new BarViewModel
{
Id = barDTO.Id,
Name = barDTO.Name,
AverageRating = barDTO.AverageRating,
Address = barDTO.Address,
Phone = barDTO.Phone,
CityName = barDTO.CityName,
Cocktails = barDTO.Cocktails.Select(c => new CocktailViewModel
{
Id = c.Id,
Name = c.Name,
AverageRating = c.AverageRating
}).ToList(),
ImageData = barDTO.ImageData,
ImageSource = barDTO.ImageSource,
};
return(barVM);
}
private void SafeBarImages(BarViewModel model, Bar bar)
{
if (model.ImageThumbnail != null)
{
string filename = bar.Id + Path.GetExtension(model.ImageThumbnail.FileName);
_fileUtility.SaveImage(model.ImageThumbnail.OpenReadStream(), "bars", "thumbnail", filename,
new Size(_configuration.GetValue <int>("Images:ThumbnailSize:Bars:X"),
_configuration.GetValue <int>("Images:ThumbnailSize:Bars:Y")));
bar.ImageThumbnail = filename;
}
if (model.ImageLarge != null)
{
string filename = bar.Id + Path.GetExtension(model.ImageLarge.FileName);
_fileUtility.SaveImage(model.ImageLarge.OpenReadStream(), "bars", "images", filename,
new Size(_configuration.GetValue <int>("Images:Bars:X"),
_configuration.GetValue <int>("Images:Bars:Y")));
bar.ImageLarge = filename;
}
if (model.ImageMobile != null)
{
string filename = bar.Id + Path.GetExtension(model.ImageMobile.FileName);
_fileUtility.SaveImage(model.ImageMobile.OpenReadStream(), "bars", "mobile", filename,
new Size(_configuration.GetValue <int>("Images:MobileSize:Bars:X"),
_configuration.GetValue <int>("Images:MobileSize:Bars:Y")));
bar.ImageMobile = filename;
}
}
public async Task <IActionResult> CreateBar(BarViewModel bar)
{
if (ModelState.IsValid)
{
try
{
var country = await countryServices.GetCountry(bar.CountryName);
bar.CountryId = country.Id;
var image = await uploadImagesServices.UploadImage(bar.Image);
bar.ImageURL = image;
var createdBar = await barServices.CreateBar(bar.GetDtoFromVM());
this.toastNotification.AddSuccessToastMessage(Exceptions.SuccessfullyCreated);
return(RedirectToAction("ListBars", "Bar", new { Area = "" }));
}
catch (Exception)
{
this.toastNotification.AddErrorToastMessage(Exceptions.SomethingWentWrong);
return(RedirectToAction("ListBars"));
}
}
return(NoContent());
}
public async Task <IActionResult> AddRating(BarViewModel bar)
{
int userId = int.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier));
var barRating = new BarRatingViewModel
{
Value = (bar.SelectedRating),
BarId = bar.Id,
UserId = userId,
};
var barRatingDto = this.barRatingVmMapper.MapDTO(barRating);
var rating = await this.barRatingService.CreateRatingAsync(barRatingDto);
var currentBar = await this.barService.GetBarAsync(rating.BarId);
var barVM = this.barVmMapper.MapViewModel(currentBar);
var DtoComments = await this.barCommentsService.GetBarCommentsAsync(barVM.Id);
barVM.Comments = this.barCommentVmMapper.MapViewModel(DtoComments);
barVM.AverageRating = this.barRatingService.GetAverageBarRating(bar.Id);
return(RedirectToAction("Details", "Bars", new { area = "", id = barVM.Id }));
}
public BarView(ToolInvokeDesc desc) :
base()
{
var vm = DataContext as BarViewModel;
DataContext = new BarViewModel(desc);
}
public void HoldsTheDataWhenTheyAreValid(double billable, double nonBillable)
{
var vm = new BarViewModel(billable, nonBillable);
vm.BillablePercent.Should().Be(billable);
vm.NonBillablePercent.Should().Be(nonBillable);
}
private void AddStopCode()
{
foreach (var bar in BarViewModel.CreateRange(new[] { 1, 1, 0, 1 }, new[] { 1d, 1d, 1d, 1d }, DefaultBarHeight))
{
Bars.Add(bar);
}
}
public async static Task <Bar> MapToEntity(this BarViewModel viewModel)
{
if (viewModel.NewPicture != null)
{
using (var stream = new MemoryStream())
{
await viewModel.NewPicture.CopyToAsync(stream);
viewModel.CurrentPicture = stream.ToArray();
}
}
var bar = new Bar()
{
Name = viewModel.Name,
Address = viewModel.Address,
PhoneNumber = viewModel.PhoneNumber,
Picture = viewModel.CurrentPicture,
IsHidden = viewModel.IsHidden,
Lat = viewModel.Lat,
Long = viewModel.Long,
Email = viewModel.Email,
};
return(bar);
}
public void ReturnDefaultView_WithBarViewModel_WithCorrectlySetCurrentUserRating()
{
//Arrange
var bar = new ShishaBar();
var barViewModel = new BarViewModel();
string userId = "1";
int rating = 5;
int barId = 2;
var mockedMappingService = new Mock <IMappingService>();
mockedMappingService.Setup(x => x.Map <ShishaBar, BarViewModel>(bar)).Returns(barViewModel);
var mockedBarsService = new Mock <IBarsService>();
mockedBarsService.Setup(x => x.GetBarById(It.IsAny <int>())).Returns(bar);
var mockedReviewsService = new Mock <IReviewsService>();
var mockedRatingService = new Mock <IRatingService>();
mockedRatingService.Setup(x => x.GetUserRating(It.IsAny <int>(), userId)).Returns(rating);
var mockedUserProvider = new Mock <IUserProvider>();
mockedUserProvider.Setup(x => x.GetUserId()).Returns(userId);
var controller = new BarController(mockedMappingService.Object,
mockedBarsService.Object,
mockedReviewsService.Object,
mockedRatingService.Object,
mockedUserProvider.Object);
//Act & Assert
controller.WithCallTo(c => c.Index(2))
.ShouldRenderDefaultView()
.WithModel <BarViewModel>(ViewModel =>
{
Assert.AreEqual(rating, ViewModel.CurrentUserRating);
});
}
public ActionResult index(BarViewModel barv)
{
int pagesize = (int)barv.page.PageSize + 8;
barv.Bars.pbars = db.Database.SqlQuery <QestDetail>("select * from V_QestDetail").OrderBy(m => m.RaiseQuesTime).ToList();
barv.Bars.pbars = barv.Bars.pbars.Where(m => m.FromName.Contains(cnts(barv.SAuthor))).ToList();
barv.Bars.pbars = barv.Bars.pbars.Where(m => m.Title.Contains(cnts(barv.SQue)) || m.Description.Contains(cnts(barv.SQue))).ToList();
barv.Bars.pbars = barv.Bars.pbars.Where(m => m.RaiseQuesTime.Contains(cnts(barv.sTime))).ToList();
if (barv.isPub != 0)
{
if ((int)barv.isPub == 1)
{
barv.Bars.pbars = barv.Bars.pbars.Where(m => m.Pub == true).ToList();
}
if ((int)barv.isPub == 2)
{
barv.Bars.pbars = barv.Bars.pbars.Where(m => m.Pub == false).ToList();
}
}
barv.page.TotalCount = barv.Bars.pbars.Count();
barv.page.PageNum = (int)Math.Ceiling((double)(barv.page.TotalCount) / pagesize);
barv.Bars.pbars = barv.Bars.pbars.OrderByDescending(m => m.RaiseQuesTime).Skip(pagesize * (barv.page.CurIndex - 1)).Take(pagesize).ToList();
return(View(barv));
}
public async Task <IActionResult> CreateBar(BarViewModel model, List <IFormFile> Picture)
{
if (!ModelState.IsValid)
{
return(View());
}
var query = model.FormatApiTemplate(model.Address.Split(' '));
var apiResult = await this.apiServices.CallApiAsync(query);
model.ParseApiResult(apiResult);
//model.NewPicture = Picture;
var bar = await model.MapToEntity();
await barServices.CreateBarAsync(bar);
foreach (var cocktail in model.Cocktails)
{
var cocktailEntity = await cocktailServices.GetAsync(cocktail);
await barCocktailServices.CreateAsync(bar, cocktailEntity);
}
//this.formattingService.HtmlStringToPDF
return(RedirectToAction("Index", "Home"));
}
public static BarViewModel MapToViewModel(this Bar bar)
{
var viewmodel = new BarViewModel();
viewmodel.Id = bar.Id;
viewmodel.Name = bar.Name;
viewmodel.Address = bar.Address;
viewmodel.PhoneNumber = bar.PhoneNumber;
viewmodel.CurrentPicture = bar.Picture;
viewmodel.BarReviews = bar.BarReviews;
viewmodel.IsHidden = bar.IsHidden;
try
{
viewmodel.Rating = Math.Round(bar.BarReviews.Select(b => b.Rating).Average(), 2);
}
catch (Exception)
{
viewmodel.Rating = 0;
}
try
{
viewmodel.Cocktails = bar.BarCocktails.Select(b => b.Cocktail.Name).Take(10).ToList();
}
catch (Exception)
{
viewmodel.Cocktails = null;
}
return(viewmodel);
}
public async Task <IActionResult> BarDetails(int Id)
{
var bar = await this._barServices.GetBarAsync(Id);
var viewModel = new BarViewModel(bar);
return(View(viewModel));
}
public async Task <IActionResult> BarDetails(string barId)
{
var bar = await barService.FindBarByIdAsync(int.Parse(barId));
var vm = new BarViewModel(bar);
return(View("BarDetails", vm));
}
private async void bSelectBar2_Click(object sender, RoutedEventArgs e)
{
mainMenu.IsEnabled = false;
SpinnerFile1.Visibility = Visibility.Visible;
tbFile.Text = "Opening";
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.InitialDirectory = Settings.Default.lastOpenedPath;
openFileDialog.Filter = "Age of Empires 3 .BAR files (*.bar)|*.bar";
string filePath;
if (openFileDialog.ShowDialog() == true)
{
filePath = openFileDialog.FileName;
Settings.Default.lastOpenedPath = Path.GetDirectoryName(filePath);
Settings.Default.Save();
tbBar2Name.ToolTip = filePath;
}
else
{
SpinnerFile1.Visibility = Visibility.Collapsed;
tbFile.Text = "Open";
mainMenu.IsEnabled = true;
return;
}
try
{
barComparer = null;
NotifyPropertyChanged("barComparer");
Bar2 = null;
NewOpen.IsChecked = false;
NotifyPropertyChanged("Bar2");
Bar2 = await BarViewModel.Load(filePath, true);
NotifyPropertyChanged("Bar2");
NewOpen.IsChecked = true;
if (Bar2.barFile.barFileHeader.Version > 5)
{
gvcEntryNewlastModifiedDate.Width = 0;
gvcEntryNewFileName.Width = 345;
}
else
{
gvcEntryNewlastModifiedDate.Width = 160;
gvcEntryNewFileName.Width = 185;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
SpinnerFile1.Visibility = Visibility.Collapsed;
tbFile.Text = "Open";
mainMenu.IsEnabled = true;
}
public async Task <IActionResult> AddBarComment(BarViewModel vm)
{
var userId = int.Parse(this.User.FindFirst(System.Security.Claims.ClaimTypes.NameIdentifier).Value);
await aService.AddBarCommentAsync(vm.Id, vm.CreateComment, userId);
var bar = await barService.FindBarByIdAsync(vm.Id);
var barForView = new BarViewModel(bar);
return(View("BarDetails", barForView));
}
public async Task <IActionResult> EditBar(BarViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View());
}
var bar = await viewModel.MapToEntity();
await this._barServices.EditBarAsync(bar);
return(RedirectToAction("Index", "Home"));
}
private async void openFile(string path = null)
{
mainMenu.IsEnabled = false;
SpinnerFile.Visibility = Visibility.Visible;
tbFile.Text = "Opening";
var filePath = path;
if (string.IsNullOrEmpty(path))
{
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Filter = "Age of Empires 3 .BAR files (*.bar)|*.bar";
if (openFileDialog.ShowDialog() == true)
{
filePath = openFileDialog.FileName;
}
else
{
SpinnerFile.Visibility = Visibility.Collapsed;
tbFile.Text = "File";
mainMenu.IsEnabled = true;
return;
}
}
try
{
file = null;
NotifyPropertyChanged("recentFiles");
NotifyPropertyChanged("file");
file = await BarViewModel.Load(filePath, DoCRC32);
if (Settings.Default.RecentFiles.Contains(filePath))
{
Settings.Default.RecentFiles.Remove(filePath);
recentFiles.Remove(recentFiles.SingleOrDefault(x => x.FileName == filePath));
}
recentFiles.Insert(0, new RecentFile()
{
FileName = filePath, Title = Path.GetFileName(filePath), OnClickCommand = new RelayCommand <string>(openFile)
});
Settings.Default.RecentFiles.Insert(0, filePath);
Settings.Default.Save();
NotifyPropertyChanged("recentFiles");
NotifyPropertyChanged("file");
}
catch (Exception e)
{
MessageBox.Show(e.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
SpinnerFile.Visibility = Visibility.Collapsed;
tbFile.Text = "File";
mainMenu.IsEnabled = true;
}
public static BarViewModel ToVMforSearch(this BarDTO bar)
{
var barViewModel = new BarViewModel();
barViewModel.BarId = bar.Id;
barViewModel.Address = bar.Address;
barViewModel.Information = bar.Information;
barViewModel.Map = bar.MapDirection;
barViewModel.Name = bar.Name;
barViewModel.Picture = bar.Picture;
barViewModel.Rating = bar.Rating;
return(barViewModel);
}
public async Task <IActionResult> GoToBar(IndexViewModel input)
{
var bar = await barService.FindBarByNameAsync(input.BarName);
if (bar != null)
{
var vm = new BarViewModel(bar);
return(View("BarDetails", vm));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
public static BarViewModel ToVMforEdit(this BarDTO bar)
{
var barViewModel = new BarViewModel();
barViewModel.BarId = bar.Id;
barViewModel.Address = bar.Address;
barViewModel.Information = bar.Information;
barViewModel.Map = bar.MapDirection;
barViewModel.Name = bar.Name;
barViewModel.Picture = bar.Picture;
barViewModel.Rating = bar.Rating;
barViewModel.BarCocktailViewModels = bar.BarCocktailDTOs.ToVM();
return(barViewModel);
}
public static async Task <BarComparer> Compare(BarViewModel bar1, BarViewModel bar2)
{
BarComparer barComparer = new BarComparer();
var barEntrys = new List <BarComparerEntry>();
await Task.Run(() =>
{
var Added = bar2.barFile.BarFileEntrys.Where(item => !bar1.barFile.BarFileEntrys.Any(item2 => item2.FileNameWithRoot == item.FileNameWithRoot)).ToList();
var Removed = bar1.barFile.BarFileEntrys.Where(item => !bar2.barFile.BarFileEntrys.Any(item2 => item2.FileNameWithRoot == item.FileNameWithRoot)).ToList();
var ChangedOld = bar1.barFile.BarFileEntrys.Where(item => bar2.barFile.BarFileEntrys.Any(item2 => item2.FileNameWithRoot == item.FileNameWithRoot && item2.CRC32 != item.CRC32)).ToList();
var ChangedNew = bar2.barFile.BarFileEntrys.Where(item => bar1.barFile.BarFileEntrys.Any(item2 => item2.FileNameWithRoot == item.FileNameWithRoot && item2.CRC32 != item.CRC32)).ToList();
var SameOld = bar1.barFile.BarFileEntrys.Where(item => bar2.barFile.BarFileEntrys.Any(item2 => item2.FileNameWithRoot == item.FileNameWithRoot && item2.CRC32 == item.CRC32)).ToList();
var SameNew = bar2.barFile.BarFileEntrys.Where(item => bar1.barFile.BarFileEntrys.Any(item2 => item2.FileNameWithRoot == item.FileNameWithRoot && item2.CRC32 == item.CRC32)).ToList();
for (int i = 0; i < ChangedOld.Count; i++)
{
barEntrys.Add(new BarComparerEntry()
{
type = "Changed", entryNew = ChangedNew[i], entryOld = ChangedOld[i]
});
}
Removed.ForEach(c => barEntrys.Add(new BarComparerEntry()
{
type = "Removed", entryOld = c, entryNew = null
}));
Added.ForEach(c => barEntrys.Add(new BarComparerEntry()
{
type = "Added", entryNew = c, entryOld = null
}));
for (int i = 0; i < SameOld.Count; i++)
{
barEntrys.Add(new BarComparerEntry()
{
type = "Unchanged", entryNew = SameNew[i], entryOld = SameOld[i]
});
}
}
);
barComparer.CompareEntries = new ReadOnlyCollection <BarComparerEntry>(barEntrys);
barComparer.CompareEntriesCollection = new CollectionViewSource();
barComparer.CompareEntriesCollection.Source = barComparer.CompareEntries;
return(barComparer);
}
public BarView(BarViewModel bar)
{
this.bar = bar;
nonBillableView = new BarSegmentView(Color.Reports.BarChart.NonBillable.ToNativeColor());
billableView = new BarSegmentView(Color.Reports.BarChart.Billable.ToNativeColor());
minimumLevelView = new BarSegmentView(
bar.BillablePercent > bar.NonBillablePercent
? Color.Reports.BarChart.Billable.ToNativeColor()
: Color.Reports.BarChart.NonBillable.ToNativeColor());
AddSubview(minimumLevelView);
AddSubview(nonBillableView);
AddSubview(billableView);
}
public void StartNewGame()
{
BoardGame = new Grid();
List = new List <TriangleUiEl>(new TriangleUiEl[24]);
BackgammonLogic = BackgammonController.Singlton
;
Bar = new BarViewModel();
BackgammonLogic.GetDiceRolls();
InitializeList();
SetGridRowAndColumns();
SetBoardLayout();
SetTriangle();
InitializeBoard();
}
public static BarViewModel MapToViewModel(this Bar bar)
{
var viewmodel = new BarViewModel
{
Id = bar.Id,
Name = bar.Name,
Address = bar.Address,
PhoneNumber = bar.PhoneNumber,
CurrentPicture = bar.Picture,
Lat = bar.Lat,
Long = bar.Long,
};
return(viewmodel);
}
public BarView(BarViewModel viewModel)
{
DataContext = viewModel;
InitializeComponent();
}
