public async Task <PagedList <User> > GetUsers(GeneralParams userParams, int hotelId)
{
var userList = await(from user in _context.Users
where user.HotelId == hotelId
orderby user.UserName
select new UserForListDto
{
Id = user.Id,
FullName = user.FullName,
Email = user.Email,
PhoneNumber = user.PhoneNumber,
Department = user.Department,
Position = user.Position,
LastActive = user.LastActive,
Roles = (from userRole in user.UserRoles
join role in _context.Roles
on userRole.RoleId
equals role.Id
select role.Name).ToList()
}).ToListAsync();
var users = _context.Users.Where(u => u.HotelId == hotelId).OrderBy(u => u.UserName).AsQueryable();
return(await PagedList <User> .CreateAsync(users, userParams.PageNumber, userParams.PageSize));
}
public async Task <PagedList <Item> > GetItems(GeneralParams generalParams)
{
var items = _context.Items.OrderByDescending(i => i.Description).AsQueryable();
if (!string.IsNullOrEmpty(generalParams.OrderBy))
{
switch (generalParams.OrderBy)
{
case "category":
items = items.OrderByDescending(i => i.Category.Description);
break;
case "price":
items = items.OrderByDescending(i => i.Price);
break;
default:
items = items.OrderByDescending(i => i.Description);
break;
}
}
if (generalParams.Category != null)
{
items = items.Where(i => i.CategoryId == generalParams.Category);
}
return(await PagedList <Item> .CreateAsync(items, generalParams.PageNumber, generalParams.PageSize));
}
public async Task <IActionResult> GetRestaurants(int hotelId, [FromQuery] GeneralParams restaurantParams)
{
var restaurants = await _repo.GetRestaurants(restaurantParams, hotelId);
var restaurantsToReturn = _mapper.Map <IEnumerable <RestaurantForListDto> >(restaurants);
Response.AddPagination(restaurants.CurrentPage, restaurants.PageSize, restaurants.TotalCount, restaurants.TotalPages);
return(Ok(restaurantsToReturn));
}
public async Task <IActionResult> GetTourists(int hotelId, [FromQuery] GeneralParams touristParams)
{
var tourists = await _hotelrepo.GetTourists(touristParams, hotelId);
var touristsToReturn = _mapper.Map <IEnumerable <TouristForListDto> >(tourists);
Response.AddPagination(tourists.CurrentPage, tourists.PageSize, tourists.TotalCount, tourists.TotalPages);
return(Ok(touristsToReturn));
}
public async Task <IActionResult> GetOpenHours(int hotelId, [FromQuery] GeneralParams openHourParams)
{
var openhours = await _repo.GetOpenHours(openHourParams, hotelId);
var openHoursToReturn = _mapper.Map <IEnumerable <OpenHoursForListDto> >(openhours);
Response.AddPagination(openhours.CurrentPage, openhours.PageSize, openhours.TotalCount, openhours.TotalPages);
return(Ok(openHoursToReturn));
}
public async Task <IActionResult> GetBaskets(int userId, [FromQuery] GeneralParams generalParams)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var baskets = await _repo.GetBaskets(generalParams);
var basketToReturns = _mapper.Map <IEnumerable <BasketForListDto> >(baskets);
Response.AddPagination(baskets.CurrentPage, baskets.PageSize, baskets.TotalCount, baskets.TotalCount);
return(Ok(basketToReturns));
}
public async Task <PagedList <User> > GetUsers(GeneralParams generalParams)
{
var users = _context.Users.OrderByDescending(u => u.LastActive).AsQueryable();
if (!string.IsNullOrEmpty(generalParams.OrderBy))
{
switch (generalParams.OrderBy)
{
case "created":
users = users.OrderByDescending(u => u.Created);
break;
default:
users = users.OrderByDescending(u => u.LastActive);
break;
}
}
return(await PagedList <User> .CreateAsync(users, generalParams.PageNumber, generalParams.PageSize));
}
public async Task <PagedList <Basket> > GetBaskets(GeneralParams generalParams)
{
var baskets = _context.Baskets.OrderBy(b => b.Title).AsQueryable();
if (!string.IsNullOrEmpty(generalParams.OrderBy))
{
switch (generalParams.OrderBy)
{
case "id":
baskets = baskets.OrderByDescending(b => b.Id);
break;
default:
baskets = baskets.OrderBy(b => b.Title);
break;
}
}
return(await PagedList <Basket> .CreateAsync(baskets, generalParams.PageNumber, generalParams.PageSize));
}
public async Task <IActionResult> GetUsers(int userId, [FromQuery] GeneralParams generalParams)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var userAdmin = await _repo.GetUser(userId);
// only admin user can see all users
if (userAdmin.UserType != 0)
{
return(Unauthorized());
}
var users = await _repo.GetUsers(generalParams);
var userToReturns = _mapper.Map <IEnumerable <UserForListDto> >(users);
Response.AddPagination(users.CurrentPage, users.PageSize, users.TotalCount, users.TotalCount);
return(Ok(userToReturns));
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
GeneralParams gnrlPrms = new GeneralParams();
options_layout.Children.Clear();
options_layout.Children.Add(gnrlPrms);
}
private void backstageTabItem1_Click(object sender, EventArgs e)
{
var gnrlPrms = new GeneralParams();
options_layout.Children.Clear();
options_layout.Children.Add(gnrlPrms);
}
public async Task <PagedList <User> > GetUsers(GeneralParams userParams, int hotelId)
{
var users = _context.Users.Where(u => u.HotelId == hotelId).OrderBy(u => u.UserName).AsQueryable();
return(await PagedList <User> .CreateAsync(users, userParams.PageNumber, userParams.PageSize));
}
public async Task <PagedList <Restaurant> > GetRestaurants(GeneralParams restaurantParams, int hotelId)
{
var restaurants = _context.Restaurants.Where(u => u.HotelId == hotelId).OrderBy(u => u.RestaurantName).AsQueryable();
return(await PagedList <Restaurant> .CreateAsync(restaurants, restaurantParams.PageNumber, restaurantParams.PageSize));
}
protected void Page_PreRender(object sender, EventArgs e)
{
//If this page is being being loaded but we have parameters from a previous visit
if (!IsPostBack && GraphInformation.SelectedParameters[ParameterNames.Country].Length != 0)
{
SetQuickNavigationMenu();
}
//Don't allow drilldown past Car Class Group
if (GraphInformation.ReportParameters.First(p => p.Name == ParameterNames.CarClassGroup).SelectedValue.Length != 0)
{
GraphInformation.AllowDrillDown = false;
}
if (GraphInformation.RefreshData || GraphInformation.CheckIfCachedDataCanBeUsed)
{
SetQuickNavigationMenu();
var rtSelectionReport = (ReportTypeParameters)GeneralParams.FindControl("rtSelectionReport");
var topicId = int.Parse(rtSelectionReport.SelectedTopic.Value);
var scenarioId = int.Parse(GeneralParams.ReportTypeControl.SelectedScenario.SelectedValue);
if (topicId > 2)
{
GraphInformation.LabelFormat = "0%";
GraphInformation.DataPointsYAxisTooltip = "#VALY{0%}";
GraphInformation.YAxisNumberFormat = "0%";
}
else
{
GraphInformation.LabelFormat = "#,##0";
GraphInformation.DataPointsYAxisTooltip = "#VALY{0,0}";
GraphInformation.YAxisNumberFormat = "#,##0";
}
if (FleetComparisonGraphData[CurrentKey] == null || GraphInformation.RefreshData)
{
//FleetComparisonGraphData[CurrentKey]=new FleetComparisonLogic(new FleetComparisonRepository()).GetData(GeneralParams.SelectedParameters,topicId,scenarioId);
FleetComparisonGraphData[CurrentKey] =
FleetComparisonDataAccess.GetFleetComarisonData(GeneralParams.SelectedParameters, topicId,
scenarioId);
GraphInformation.DataDate = ParameterDataAccess.GetLastDateFromCmsForecast();
}
else
{
GraphInformation.UsingCachedGraphingData = true;
}
GraphInformation.SeriesData = FleetComparisonGraphData[CurrentKey];
if (string.IsNullOrEmpty(GraphInformation.TitleDate))
{
GraphInformation.ShowLabelSeriesNames.Add(GraphInformation.SeriesData.First().SeriesName);
}
this.SetPreviousDates(GeneralParams);
GraphInformation.CalculateYEntriesCount();
GraphInformation.TitleDate = string.Format("{0} - {1}", GeneralParams.SelectedParameters[ParameterNames.FromDate], GeneralParams.SelectedParameters[ParameterNames.ToDate]);
GraphInformation.TitleAdditional = string.Format("{0}", rtSelectionReport.SelectedTopic.Text);
GraphInformation.RefreshData = false;
}
}
public async Task <PagedList <Payment> > GetPayments(GeneralParams paymentParams, int hotelId)
{
var payments = _context.Payments.Where(u => u.HotelId == hotelId).OrderBy(u => u.PaymentName).AsQueryable();
return(await PagedList <Payment> .CreateAsync(payments, paymentParams.PageNumber, paymentParams.PageSize));
}
public async Task <PagedList <Category> > GetCategories(GeneralParams generalParams)
{
var categories = _context.Categories.OrderByDescending(c => c.Description).AsQueryable();
return(await PagedList <Category> .CreateAsync(categories, generalParams.PageNumber, generalParams.PageSize));
}
public async Task <PagedList <Room> > GetRooms(GeneralParams roomParams, int HotelID)
{
var rooms = _context.Rooms.Where(u => u.HotelId == HotelID).OrderBy(u => u.RoomNo).AsQueryable();
return(await PagedList <Room> .CreateAsync(rooms, roomParams.PageNumber, roomParams.PageSize));
}
public async Task <PagedList <Tourist> > GetTourists(GeneralParams touristParams, int HotelID)
{
var tourists = _context.Tourists.Where(u => u.HotelId == HotelID).OrderBy(u => u.TouristType).AsQueryable();
return(await PagedList <Tourist> .CreateAsync(tourists, touristParams.PageNumber, touristParams.PageSize));
}
public async Task <PagedList <OpenTime> > GetOpenHours(GeneralParams openHourParams, int hotelId)
{
var openHours = _context.OpenTimes.Where(u => u.HotelId == hotelId).OrderBy(u => u.Type).AsQueryable();
return(await PagedList <OpenTime> .CreateAsync(openHours, openHourParams.PageNumber, openHourParams.PageSize));
}
